Python Programming Made Easy: For Beginners Grade 11 & 12 ...

PrefaceWhen I started teaching Python 2 years ago, I was amazed to find a variety of

learningresourcesonline.Ilearntthelanguageandstartedteachingittomystudents.Butitbecameincreasinglydifficulttoputtogethersomeconceptsandcreateapplications.Thefreetutorialsdidnotexplain,forexample,howtopopulateadictionarywithvaluesfromtheuser.It tookalotoftimetorefergoodbooksandcreateteachingnotes.Thesenoteshavetakentheshapeofthisbook.Pythonisasimpleyetpowerfulprogramminglanguage.Theentire focusof thisbook is tosimplify thebasicconceptsofPython. It isbasedonsyllabusofschoolsandengineeringcollegesandshouldcatertoanybeginnerwishingtolearnPython.

Thebookisorganizedinto13chaptersasfollows

Chapter 1 deals with installation and running the first Python program. ThischapterneedstobetaughtinthelabandifPythonisalreadyinstalled,itshouldtake10-20 minutes to understand interactive and script modes. Chapter 2 explains variables,datatypesandoperators.ThereareafewspecialoperatorsinPython.Chapter3explainsthefunctionsinPython.Italsoexplainsthevarioustypesofarguments.Chapter4dealswith the control structures. It contains a lot of simple programs using if, for andwhilestructures. Chapter 5 explains the string module functions. Simple programs using thebuilt in functions are explained. Chapter 6 explains the handling of lists. Various listfunctions are also explained. Chapter 7 explains the Python dictionaries and theirapplication.Chapter8explainstuplefunctions.

Chapter9 introduces theconceptsofclasses,objectsandinheritance.Chapter10explains data structures. Searching and sorting algorithms are explained. Stacks andQueuesareexplainedwithPython implementation.Chapter11explains thedata files inPython.FilesareabeautyofthislanguagecomparedtoC++.Theeasewithwhichwecantalk to files from Python is amazing. Chapter 12 explains exception handling andgenerator functions. Chapter 13 has 4 interesting projects. These were done by mystudents aspart of their projectwork.Similar to files, database access is also relativelysimpleinPython.ThecodegiveniswithSQLServer.

Thisbook is intended tobesimpleyeteffectiveforstudentswhowoulduse thisready reference for better preparation. All programs have been thoroughly tested and

screenshotsareprovidedaftereveryprogramforbetterunderstanding.

Author

Acknowledgement

Bookwritinghasbeenmyhobbyforthepast3yearsanditrequiresalotoftimeandhardwork.MyentirefamilyhasstoodbymethroughoutmybookwritingjourneyandIthankthemallfromthebottomofmyheart.

Iwouldliketothankmyhusband,Mr.Karthik,forthetechnicalreviewofthebook.Hehasbeenaconstantsourceofmotivation.Mykids,NiranjanandNivedha,gavemethetimeandspaceforbookwriting.

Myfriendsandcollegueswerealwayssupportiveingivingmeconstructivefeedbacktoimprovemybooks.

Lastbutnottheleast,Iwouldliketothankeachoneofmystudents.Istatedwritingbooksforthemandeachsessionwiththemhaskindlednewideas.

Ithankthereadersforyourcontinuedsupport.Yourfeedbackisveryvaluableforimprovingthisbook.

Pavithra

Email:pavithrakarthikcs@gmail.com

Contents

Chapter1:IntroductiontoPython

InstallingPython2.7&Executingthefirstprogram

Chapter2:Variables,datatypesandoperators

Keywords

Datatypes

Datatypeconversions

Operators

Inputandoutput

SolvedQuestions

PracticeProblems

Chapter3:FUNCTIONS

Built-infunctions

Modules

User–definedfunctions

ParametersandArguments

Anonymousfunctions

Scopeofvariables

SolvedQuestions

Practiceproblems

Chapter4:Conditionalconstructsandlooping

Conditionalconstructs

Iterationstructures

SolvedPrograms

PracticeProblems

Chapter5:Strings

AccessingValuesinStrings

UpdatingStrings

EscapeCharacters

StringSpecialOperators

StringFormattingOperator

Built-instringfunctions

Stringconstants

RegularexpressionsandPatternmatching

Functionsfromremodule

SolvedPrograms

PracticeProblems

Chapter6:Lists

Listoperations

Slicing

Negativeindexing

Listfunctions

Matrices

Matriximplementationusinglist

SolvedQuestions

Practiceproblems

Chapter7:DICTIONARIES

Creatingadictionary

CharacteristicsofPythonDictionaries

AccessingValuesinDictionary

UpdatingDictionary

DeleteDictionaryElements

Built-inDictionaryFunctions&Methods

SolvedPrograms

PracticeProblems

Chapter8:Tuples

TupleCreation

Tupleinsertion

Tupleinitialization

TupleAssignment

TupleSlices

UpdatingTuples

DeleteTupleElements

BasicTuplesOperations

Built-inTupleFunctions

SolvedPrograms

PracticeProblems

Chapter9:Classes,ObjectsandInheritance

Namespaces

Definingclasses

Objects

ACCESSINGATTRIBUTES

BUILT-INCLASSATTRIBUTES

__del()__ordestructor

__str()__

Privatevariables

DYMANICALLYADDINGMETHODS

DynamicClassMethodAddition

DynamicInstanceMethodAddition

StaticMethods

DestroyingObjects(GarbageCollection)

Inheritance

Formsofinheritance

BaseOverloadingMethods

SingleInheritance

MULTILEVELINHERITANCE

MultipleInheritance

MethodOverriding

Abstractmethods

SolvedQuestions

PracticeQuestions

Chapter10:Datastructures

Lineardatastructure

Non-Lineardatastructure

AlgorithmsonListOperations

Traversal

Insertion

Deletion

ArraySearching

ArraySorting

Stacks

Applicationofstacks

Deque(Double-endedqueues)

CircularQueues

SolvedExamples

PracticeQuestions

Chapter11:DATAFILEHANDLING

OpenFunction

FileopeningModes

Thefileobjectatrributes

Openingafile

FileMethods

osmodulefunctions

Operationsontextfiles

Writing/Creatingatextfile

Readingfromatextfile

Traversal/Display

Deletion

Updation

RandomAccess

Binaryfiles

Writinginabinaryfile

Readingfromabinaryfile

BinaryfileManipulation

SolvedQuestions

PracticeQuestions

Chapter12:ExceptionHandling&Generators

Exceptionhandling

User-DefinedExceptions

Generatorfunctions

SolvedExamples

PracticeQuestions

Chapter13:SampleApplications

Project1:Inventorymanagement

Project2:Quiz

Project3:Databasesoperationsusingpython

Project4:CALCULATOR

Solutionstopracticequestions(selected)

Referencebooks

Weblinks

Otherbooksbythesameauthor

Chapter1:IntroductiontoPython

Pythonwas createdbyGuidoVanRossum in1991.Pythongot its name fromaBBCcomedyseries–“MontyPython’sFlyingcircus”.

Pythonisaninterpretedhigh-levellanguage,whichmakesitfasterthanothercompiledlanguages.Thehigh-leveldatatypesallowustoexpresscomplexoperationsinasinglestatement.Statementgroupingisdonebyindentationinsteadofbeginningandendingbrackets. No variable or argument declarations are necessary. It is suitable as anextension language for customizable applications. It has a wide library of add-onmodules.Itisaplatformindependentprogramminglanguage

InstallingPython2.7&ExecutingthefirstprogramPythonisafreeware.AllexamplesinthisbookareofPython2.7.

ToinstallPython,gotohttp://www.python.org/download/releases/2.7/

IDLEisthestandardmostpopularPythondevelopmentenvironment.IDLEisanacronymofIntegratedDevelopmentEnvironment.

1.WeneedtogotoStart � IDLE

Fig1.1:IDLEIcon

WhenwestartuptheIDLEfollowingwindowwillappear.

Fig1.2:IDLEwindow

>>>promptmeansthattheinterpreterisexpectingapythoncommand

…indicatesthattheinterpreteriswaitingforadditionalinputtocompletethecurrentstatement.

WetypePythonexpression/statement/commandafterthepromptandPythonimmediatelyrespondswiththeoutputofit.

Fig1.3:Firstprogram

Aftertypingapythoncommand,pressEnter

Fig1.4:Outputscreenshot

Pythonininteractivemodehelpsustolearnbetterbutwecannotsavethestatementsforfurtheruse.Interactivemodeissuitedonlyforbeginnersorfortestingsmallpiecesofcode.

Inscriptmode,wetypePythonprograminafileandthenusetheinterpretertoexecutethecontentfromthefile.Workingininteractivemodeisconvenientforbeginnersandfortestingsmallpiecesofcode,aswecantestthemimmediately.Butforcodingmorethanfewlines,weshouldalwayssaveourcodesothatwemaymodifyandreusethecode.

Steps:

1. FirstgotoFile � NewWindow

Fig1.5:Scriptmode1

2. Wecanseeablankwindowpoppingup

Fig1.6:Scriptmode2

3. WritethePythoncode

Fig1.7:Scriptmode3

4. Saveitwith“.py”extension

Fig1.8:ScriptMode4

5. ExecutebypressingShift+F5keyorrunoption

Fig1.9:ScriptMode5

6. Verifytheoutput

Fig1.10:ScriptMode6

Chapter2:Variables,datatypesandoperators

Variablesarereservedmemorylocationstostorevalues.Avariablehasaname,atypeandavalue.

InlanguageslikeC,C++orJavaweneedtoexplicitlydeclarevariablesPythonvariablesneednotbeexplicitlydeclared.Thedeclarationhappensautomaticallywhenweassignavaluetoavariable.

Name=“India”#Astring

(NamevalueType)

Wecanassignmultiplevaluestomultiplevariablesinasinglestatement.

a,b,c=1,2.0,“Hello”

Example2.1:Whatarethevaluesofxandyafterthecodeisexecuted.

printx,y,z

Afterthesefourlinesofcodeareexecuted,xis4,yis5andzis8.

1.xstartswiththevalue3andystartswiththevalue4.2.Inline3,avariableziscreatedtoequalx+y,whichis7.3.Thenthevalueofzischangedtoequalonemorethanitcurrentlyequals,changingitfrom7to8.

4.Next,xischangedtothecurrentvalueofy,whichis4.

5.Finally,yischangedto5.Notethatthisdoesnotaffectx.6.Soattheend,xis4,yis5,andzis8.Rulesfornamingvariables

1.Variablenamescancontaina-z,A-Z,0-9and‘_’(underscore)2.Variablenameshouldnotbeginwithadigit3.Itshouldnotbeakeyword4.Itcanbeofanylength

5. Variablenamescannotcontainspaces.6. Casematters—forinstance,tempandTemparedifferent.

Example2.2:Whichofthefollowingvariablenamesareinvalid?Justify.

a)tryb)123Helloc)abc@dd)sum

a)try–It’sakeywordandcan’tbeusedasavariablename

b)123Hello–Variablenamescan’tstartwithadigit

c)abc@d–Specialcharactersaren’tallowedinvariablenames.

Amutableobjectexhibitstime-varyingbehavior.Changestoamutableobjectarevisiblethroughallnamesboundtoit.Ex:lists

Animmutableobjectdoesnotexhibittime-varyingbehavior.Thevalueofimmutableobjectscannotbemodifiedaftertheyarecreated.Theycanbeusedtocomputethevaluesofnewobjects.Ex:strings,tuples

Keywords

Fig2.1:Pythonkeywordlist

DatatypesDatatypeisasetofvaluesandtheallowableoperationsonthosevalues.Python

hasagreatsetofusefuldatatypes.Python’sdatatypesarebuiltinthecoreofthelanguage.Theyareeasytouseandstraightforward.

Fig2.2:PythonDatatypes

Numberscanbeeitherintegersorfloatingpointnumbers.

Asequenceisanorderedcollectionofitems,indexedbyintegersstartingfrom0.Sequencescanbegroupedintostrings,tuplesandlists.

Stringsarelinesoftextthatcancontainanycharacters.Theycanbedeclaredwithsingleordoublequotes.

Listsareusedtogroupotherdata.Theyaresimilartoarrays.

Atupleconsistsofanumberofvaluesseparatedbycommas.

Asetisanunorderedcollectionwithnoduplicateitems.

Adictionaryisanunorderedsetofkey:valuepairswherethekeysareunique

Datatypeconversions

Thereareseveralbuilt-infunctionstoperformconversionsfromonetypetoanother.

Function Description

int(x[,base]) Convertsxtoaninteger.basespecifiesthebaseifxisastring.

long(x[,base]) Convertsxtoalonginteger.basespecifiesthebaseifxisastring.

float(x) Convertsxtoafloating-pointnumber.

complex(real[,imag])

Createsacomplexnumber.

str(x) Convertsobjectxtoastringrepresentation.

repr(x) Convertsobjectxtoanexpressionstring.

eval(str) Evaluatesastringandreturnsanobject.

tuple(s) Convertsstoatuple.

list(s) Convertsstoalist.

set(s) Convertsstoaset.

dict(d) Createsadictionary.dmustbeasequenceof(key,value)tuples.

frozenset(s) Convertsstoafrozenset.

chr(x) Convertsanintegertoacharacter.

unichr(x) ConvertsanintegertoaUnicodecharacter.

ord(x) Convertsasinglecharactertoitsintegervalue.

hex(x) Convertsanintegertoahexadecimalstring.

oct(x) Convertsanintegertoanoctalstring.

Table2.1:PythonDataconversionfunctions

Example2.3:Programthatcomputestheaverageoftwonumbersthattheuserenters.

num1=int(raw_input(‘Enterthefirstnumber:’))

num2=int(raw_input(‘Enterthesecondnumber:‘))

print(‘Theaverageofthenumbersyouenteredis‘,(num1+num2)/2)

Forthisprogramweneedtogettwonumbersfromtheuser.Wegetthenumbersoneatatimeandgiveeachnumberitsownname.Allmultiplicationsanddivisionsareperformedbeforeanyadditionsandsubtractions,sowehavetouseparenthesestogetPythontodotheadditionfirst.

OperatorsOperatorsarespecialsymbolswhichperformsomecomputation.Operatorsand

operandsformanexpression.

Pythonoperatorscanbeclassifiedasgivenbelow.

Fig2.3:Pythonoperatortypes

Let’sexploreeachoftheseoperatorsindetail

ArithmeticOperators

Arithmeticoperatorshelpustoperformvariousarithmeticcalculations.Thearithmeticoperatorsareexplainedinthetablebelow.Let’sassumevalueofa=2andb=3

Operator Description Example

+ Addition-Addsvaluesoneithersideoftheoperator

a+bresultsin5

- Subtraction-Subtractsrighthandoperandfromlefthandoperand

a–bresultsin-1

* Multiplication-Multipliesvaluesoneithersideoftheoperator

a*bresultsin6

/ Division-Divideslefthandoperandbyrighthandoperand

a/bresultsin0

% Modulus-Divideslefthandoperandbyrighthandoperandandreturnsremainder

a%bresultsin2

** Exponent-Performsexponential(power)calculationonoperators

a**bresultsin8

// FloorDivision-Thedivisionofoperandswheretheresultisthequotientinwhichthedigitsafterthedecimalpointareremoved.

11//2resultsin5

11.0//2.0resultsin5.0

Table2.2:Pythonarithmeticoperators

Relational/ComparisonOperators

Theseoperatorshelpustomakedecisionsbasedoncertainconditions.

== Checksifthevalueoftwooperandsareequalornot,ifyesthenconditionbecomestrue.

(a==b)isnottrue.

!= Checksifthevaluesoftwooperandsareequalornot,ifvaluesarenotequalthenconditionbecomestrue.

(a!=b)istrue.

<> Checksifthevalueoftwooperandsareequalornot,ifvaluesarenotequalthenconditionbecomestrue.

(a<>b)istrue.Thisissimilarto!=operator.

> Checksifthevalueofleftoperandisgreaterthanthevalueofrightoperand,ifyesthencondition

(a>b)isnottrue.

becomestrue.

< Checksifthevalueofleftoperandislessthanthevalueofrightoperand,ifyesthenconditionbecomestrue.

(a<b)istrue.

>= Checksifthevalueofleftoperandisgreaterthanorequaltothevalueofrightoperand,ifyesthenconditionbecomestrue.

(a>=b)isnottrue.

<= Checksifthevalueofleftoperandislessthanorequaltothevalueofrightoperand,ifyesthenconditionbecomestrue.

(a<=b)istrue.

Table2.3:Pythonrelationaloperators

AssignmentOperators

Theseoperatorsassigntherightsidevaluetotheleftsidevariable.

= Simpleassignmentoperator,Assignsvaluesfromrightsideoperandstoleftsideoperand

c=a+bwillassignthevalueofa+bintoc

+= AddANDassignmentoperator,Itaddsrightoperandtotheleftoperandandassigntheresulttoleftoperand

c+=aisequivalenttoc=c+a

-= SubtractANDassignmentoperator,Itsubtractsrightoperandfromtheleftoperandandassigntheresulttoleft

c-=aisequivalentto

c=c–a

operand

*= MultiplyANDassignmentoperator,Itmultipliesrightoperandwiththeleftoperandandassigntheresulttoleftoperand

c*=aisequivalenttoc=c*a

/= DivideANDassignmentoperator,Itdividesleftoperandwiththerightoperandandassigntheresulttoleftoperand

c/=aisequivalenttoc=c/a

%= ModulusANDassignmentoperator,Ittakesmodulususingtwooperandsandassigntheresulttoleftoperand

c%=aisequivalenttoc=c%a

**= ExponentANDassignmentoperator,Performsexponential(power)calculationonoperatorsandassignvaluetotheleftoperand

c**=aisequivalenttoc=c**a

//= FloorDivisionANDassignsavalue,Performsfloordivisiononoperatorsandassignvaluetotheleftoperand

c//=aisequivalenttoc=c//a

Table2.4:Pythonassignmentoperators

Bitwiseoperators

Bitwiseoperatorworksonbitsandperformbitbybitoperation.Assumeifa=65;andb=12;Nowinbinaryformattheywillbeasfollows:

a=01000001

b=00001100

a&b=00000000

a|b=01001101

a^b=01001101

~a=10111110

Table2.5:Bitwiseoperations

ThetablebelowliststhebitwiseoperatorsinPython.Let’sassumea=65andb=12forthisexample.

& BinaryANDOperatorcopiesabittotheresultifitexistsinbothoperands.

(a&b)resultsin0(00000000)

| BinaryOROperatorcopiesabitifitexistsineitheroperand.

(a|b)resultsin77whichis1001101

^ BinaryXOROperatorcopiesthebitifitissetinoneoperandbutnotboth.

(a^b)resultsin77whichis1001101

~ BinaryOnesComplementOperatorisunaryandhastheeffectof‘flipping’bits.

(~a)resultsin-66whichis10111110.

<< BinaryLeftShiftOperator.Theleftoperandsvalueismovedleftbythenumberofbitsspecifiedbytheright

a<<2resultsin260whichis100000100

operand.

>> BinaryRightShiftOperator.Theleftoperandsvalueismovedrightbythenumberofbitsspecifiedbytherightoperand.

a>>2resultsin16whichis10000

Table2.6:Pythonbitwiseoperators

LogicalOperators

TherearefollowinglogicaloperatorssupportedbyPythonlanguage.

and LogicalANDoperator.Ifboththeoperandsaretruethenthenconditionbecomestrue.

a=5b=10

(aandb)istrue.

or LogicalOROperator.Ifanyofthetwooperandsarenonzerothenthenconditionbecomestrue.

(aorb)istrue.

not LogicalNOTOperator.Usetoreversesthelogicalstateofitsoperand.IfaconditionistruethenLogicalNOToperatorwillmakefalse.

not(a)isfalse.

Table2.7:Pythonlogicaloperators

MembershipOperators

Pythonhasmembershipoperators,whichtestformembershipinasequence,suchasstrings,lists,ortuples.Therearetwomembershipoperatorsexplainedbelow:

In Evaluatestotrueifitfindsavariable Y=[]

inthespecifiedsequenceandfalseotherwise.

Ifxiny:

return1ifxisamemberofsequencey.

notin Evaluatestotrueifitdoesnotfindsavariableinthespecifiedsequenceandfalseotherwise.

Ifxnotiny:

herenotinresultsina1ifxisnotamemberofsequencey.

Table2.8:Pythonmembershipoperators

IdentityOperators

Identityoperatorscomparethememorylocationsoftwoobjects.TherearetwoIdentityoperatorsexplainedbelow:

Is Evaluatestotrueifthevariablesoneithersideoftheoperatorpointtothesameobjectandfalseotherwise.

xisy,hereisresultsin1ifid(x)equalsid(y).

isnot Evaluatestofalseifthevariablesoneithersideoftheoperatorpointtothesameobjectandtrueotherwise.

xisnoty,hereisnotresultsin1ifid(x)isnotequaltoid(y).

Table2.9:Pythonidentityoperators

Operatorprecedence

Thefollowingtablelistsalloperatorsfromhighestprecedencetolowest.

Operator Description

** Exponentiation(raisetothepower)

~+- Complement,unaryplusandminus(methodnamesforthelasttwoare+@and-@)

*/%// Multiply,divide,moduloandfloordivision

+- Additionandsubtraction

>><< Rightandleftbitwiseshift

& Bitwise‘AND’

^| Bitwiseexclusive`OR’andregular`OR’

<=<>>= Comparisonoperators

<>==!= Equalityoperators

=%=/=//=-=+=*=**=

Assignmentoperators

is,isnot Identityoperators

innotin Membershipoperators

notorand Logicaloperators

Table2.10:Operatorprecedence

Example2.4:ThefollowingexampleillustratesoperatorprecedenceinPython.

e=(a+b)*c/d#(3*3/4)=9/4

print“Valueof(a+b)*c/dis“,e

f=((a+b)*c)/d#(3*3)/4=9/4

print“Valueof((a+b)*c)/dis“,f

g=(a+b)*(c/d);#(3)*(3/4)=0

print“Valueof(a+b)*(c/d)is“,g

h=a+(b*c)/d;#1+(2*3)/4=1+6/4=10/4

print“Valueofa+(b*c)/dis“,h

Inputandoutput

Pythontakesthedataenteredbytheuserusing2functions

raw_input():raw_input([prompt])

input():input([prompt])

raw_input()

Thefunctiontakesexactlywhatistypedfromkeyboard,convertsittostringandstoresitinthevariable.

>>>x=raw_input(“Enteryourname”)

Enteryourname

Ifweneedtogetnumericvaluesfromtheuser,weneedtouseint().

>>>y=int(raw_input(“Entertherollno.”))

Entertherollno

Thefunctionint()convertsthestringtointeger.

input()

input()evaluatestheinputtypedatthepromptanditexpectsavalidpythonexpression.Iftheinputprovidedisn’tcorrecttheneitherasyntaxerrororexceptionisraisedbyPython.

print()

print()communicatestheprogram’sresulttotheenduser.Itevaluatestheexpressionbeforeprintingitonthemonitor.

print()movestothenextlineafterprintingonestatement.

>>>print4+6

Toprintinthesamelinewecanusecomma’s

print“I”,

print“Love”,

print“Python”

Fig2.4:print()

Comments

Programnoteswhichexplainthepurposeofaprogramareknownascomments.InPython,commentscanbe

singleline:startswith“#”

#calculatesimpleinterest

multiline:startswith‘’’’’’

“””calculatesimpleinterest

Usingformula(pnr)/100“””

SolvedQuestions1. Writeaprogramtogetthesideofasquarefromtheuserandprintitsarea.

side=int(raw_input(“Enterthesideofasquare”))

area=side*side

print“Areaofsquare=”,area

2. Writeaprogramtocalculatesimpleinterest.

principal=float(raw_input(“Entertheprincipalamount”))

years=float(raw_input(“Entertheno.ofyears”))

rate=float(raw_input(“Enterrateofinterest”))

si=(principal*years*rate)/100

print“SimpleInterest=”,si

3. Thefollowingprogramisnotgivingtheintendedoutput.Inputgivenis4andtheexpectedoutputis16.Findtheerror.

N=raw_input(“Enternumber”)

printS

Thenumberistreatedasastring.So,ifweconvertittointegerwewillgetthedesiredoutput.

N=int(raw_input(“Enternumber”))

PracticeProblems1. Writeacodethataskstwopeoplefortheirnames;storesthenamesinvariables

calledname1andname2;sayshellotobothofthem.2. WriteaprogramtogetatemperatureinCelciusandconvertitintoFarenheitusing

theformulaF=C*9/5+32.3. Predicttheoutput

a)print4*5+9*2–8%3+9

b)print8.7//2–1+4ornot2==4andnot2**4>6*3

Chapter3:FUNCTIONS

Functionsarethemostimportantbuildingblocksinanyprogramminglanguage,especiallyPython.Afunctionisablockofstatementsthatperformacomputation.Thelinesofcodeinsideafunctionareexecutedsequentially.

Fig3.1:Functions

Built-infunctions

Built-infunctionsarethefunctionsthatarebuiltintoPythonandcanbeaccessedbyaprogrammer.

Table3.1:Pythonbuilt-infunctions

Someimportantfunctionsareexplainedbelow

S.No Function Description Example

1 abs(x) Returntheabsolutevalueofanumber.Theargumentmaybe

abs(-4.0)

aplainorlongintegerorafloatingpointnumber.Iftheargumentisacomplexnumber,itsmagnitudeisreturned.

2 cmp(x,y) Comparethetwoobjectsxandyandreturnanintegeraccordingtotheoutcome.Thereturnvalueisnegativeifx<y,zeroifx==yandstrictlypositiveifx>y.

cmp(6,7)

3 divmod(a,b) Taketwo(noncomplex)numbersasargumentsandreturnapairofnumbersconsistingoftheirquotientandremainderwhenusinglongdivision.

divmod(8,8)

4 len(s) Returnthelength(thenumberofitems)ofanobject.Theargumentmaybeasequence(string,tupleorlist)oramapping(dictionary).

len(“Python”)

5 max(arg1,arg2,*args[,key])

Returnthelargestiteminaniterableorthelargestoftwoormorearguments.

Theoptionalkeyargumentspecifiesaone-argumentorderingfunctionlikethatusedforlist.sort().Thekeyargument,ifsupplied,mustbeinkeywordform(forexample,max(a,b,c,key=func)).

max(8,56,34)

max(“India”,“China”,“Japan”)

‘Japan’

6 min(arg1,arg2,*args[,key]) Returnthesmallestiteminaniterableorthesmallestoftwoormorearguments.

Theoptionalkeyargumentspecifiesaone-argumentorderingfunctionlikethatusedforlist.sort().Thekeyargument,ifsupplied,mustbeinkeywordform(forexample,min(a,b,c,key=func)).

min(8,56,34)

min(‘India’,‘China’,‘Japan’)

‘China’

7 range(stop)

range(start,stop[,step])

Thisisaversatilefunctiontocreatelistscontainingarithmeticprogressions.Itismostoftenusedinforloops.Theargumentsmustbeplainintegers.

Ifthestepargumentisomitted,itdefaultsto1.

Ifthestartargumentisomitted,itdefaultsto0.stepmustnotbezero(orelseValueErrorisraised).

foriinrange(0,20,2):

printi,

024681012141618

8 round(number[,ndigits]) Returnthefloatingpointvaluenumberroundedtondigitsdigitsafterthedecimalpoint.Ifndigitsisomitted,itdefaultstozero.

round(0.5)

round(-2.2)

round(3.14127,2)

9 type(object)

type(name,bases,dict)

Withoneargument,returnthetypeofanobject.Thereturnvalueisatypeobject.Theisinstance()built-infunctionisrecommendedfortestingthetypeofanobject.

str=“Python”

type(str)

<type‘str’>

type(a)

<type‘int’>

10 tuple([iterable]) Returnatuplewhoseitemsarethesameandinthesameorderasiterable‘sitems.

tuple([1,2,3,4,5])

(1,2,3,4,5)

11 id(object) Returnthe“identity”ofanobject.Thisisaninteger(orlonginteger)whichisguaranteedtobeuniqueandconstantforthisobjectduringitslifetime.Twoobjectswithnon-overlappinglifetimesmayhavethesameid()value.

30991416L

Table3.2:Importantbuilt-infunctions

*Datatypeconversionfunctionshavebeenalreadydiscussedinchapter2

Modules

AmoduleisafilecontainingPythondefinitionsandstatements.Weneedtoimportmodulestouseanyofitsfunctionsorvariablesinourcode.

Syntax:

importmodulename1[,modulename2,…]

Example:

importmath

value=math.sqrt(25)

Syntax:

Frommodulenameimportfunctionname[,functionname]

Example:

frommathimportsqrt

value=sqrt(25)

Note:It’sagoodprogrammingpracticetoputalltheimportstatementsatthebeginningofthePythonfile.

Someimportantmodulesaremath,random,string,time,date.

Mathmodule

Someimportantfunctionsinmathmodulearelistedinthetablebelow

Function Description Example

ceil(x) Returnthesmallestintegervaluegreaterthanorequaltox.

importmath

math.ceil(40.3)

floor(x) Returnthelargestintegervaluelessthanorequaltox.

math.floor(39.9)

exp(x) Returnsex math.exp(1)

2.718281828459045

pow(x,y) Returnsxy math.pow(8,3)

sqrt(x) Returnthesquarerootofx. math.sqrt(25)

hypot(x,y)

ReturntheEuclideannorm,sqrt(x*x+y*y).Thisisthelengthofthevectorfromtheorigintopoint(x,y).

math.hypot(6,6)

8.48528137423857

degrees(x) Convertsanglexfromradianstodegrees.

math.degrees(3.14)

179.9087476710785

radians(x) Convertsanglexfromdegreestoradians.

math.radians(180)

3.141592653589793

cos(x) Returnthecosineofx. math.cos(0)

sin(x) Returnthesineofx. math.sin(0)

tan(x) Returnthetangentofx. math.tan(0)

pi Themathematicalconstantpi.

math.pi

3.141592653589793

e Themathematicalconstante

math.e

2.718281828459045

Table3.3:Mathmodule

Randommodule

Someimportantfunctionsinrandommodulearelistedinthetablebelow

random.randrange(stop)

random.randrange(start,stop[,step])

Returnarandomlyselectedelementfromrange(start,stop,andstep).

printrandom.randrange(2,10)

random.randint(a,b) ReturnarandomintegerNsuchthata<=N<=b.

printrandom.randint(8,20)

random.seed([x]) Initializethebasicrandomnumbergenerator.Optionalargumentxcanbeanyhashableobject.IfxisomittedorNone,currentsystemtimeisused;

random.seed(5)

printrandom.randint(0,10)

random.choice(seq) Returnarandomelementfromthenon-emptysequenceseq.Ifseqisempty,raisesIndexError.

printrandom.choice(“Python”)

Table3.4:randommodule

StringmoduleisdiscussedinChapter5

User–definedfunctions

Pythonprovidesmanybuiltinfunctions.Butwecanalsocreateourownfunctions.Thesefunctionsarecalleduser-definedfunctions.Thereareafewrulesfordefiningourownfunctions.

1. Functionblocksbeginwiththekeyword“def”followedbythefunctionnameandparantheses.

2. Thefirststatementofafunctioncanbeanoptionalstatement–docstring.Itisthedocumentationstringofthefunctionwhichcontainsessentialinformationaboutthefunctionsuchas

purposeofafunction

typesofparameters

returnvalues

3. Anyinputparametersshouldbeplacedwithintheseparameters.4. Thestatementreturn[expression]exitsafunction,optionallypassingbackan

expressiontothecaller.AreturnstatementwithnoargumentsisthesameasreturnNone.

5. Bydefault,parametershaveapositionalbehaviour,andweneedtoinformtheminthesameorderastheyweredefined.

Example3.1:Functiontoadd2numbers

defadd(a,b):

”’Thisfunctionsadds2numbers”’

returnc

ParametersandArguments

Parametersarethevaluesprovidedintheparenthesisinthefunctionheaderwhenwedefinethefunction.Argumentsarethevaluesprovidedinfunctioncall/invokestatement.

Fig3.2:Functionarguments/parameters

Fig3.3:Typesofparameters

Requiredargumentsaretheargumentspassedtoafunctionincorrectpositionalorder.Somefunctionsrequiretheargumentstobeprovidedforalltheparametersandorderofargumentsshouldbethesameasinthedefinition.

Defaultargumentsassumeadefaultvalueifavalueisnotprovidedinthefunctioncallforthatargument.Aparameterhavingadefaultvalueinfunctionheaderbecomesoptionalinfunctioncall.Functioncallmayormaynothavevalueforit.Theyareused

Toaddnewparameterstotheexistingfunction

Tocombinesimilarfunctions

Toprovidegreaterflexibilitytoprogrammers

Keywordargumentsallowsustoskipargumentsorplacethemoutoforderbecausetheinterpreterisabletousethekeywordsprovidedtomatchthevalueswithparameters.Thecallingfunctionidentifiestheargumentsbytheparametername.ThisisauniquefeatureofPythonwherewecanwriteanyargumentinanyorderprovidedwenamethearguments.Wecanpassadictionaryasanargument.

Thecodesnippetbelowexplainsit.

deffunc(a=‘aa’,b=‘bb’,c=‘cc’,**keyargs):

…printa,b,c

>>>func()

aabbcc

>>func(**{‘a’:‘x’,‘b’:‘y’,‘c’:‘z’})

Here,theorderofparameterdoesnotmatter.

Advantages:

1. Weneednotremembertheorderofthearguments2. Wecanspecifyvaluestoonlythoseparameterswewantto

Variable-lengthargumentsarenotnamedinthefunctiondefinition.

Example3.2:Variable-lengtharguments

defadd(*numbers):

fornumberinnumbers:

sum=sum+number

printsum

add(1,2,3,4,5)

add(2,4,6)

Thisallowsustoaddanynumberofvalues.

Anonymousfunctions

Functionsusingthelamdakeywordwithoutusing“def”keywordarecalled

anonymousfunctions.

Example3.3:Anonymousfunctions

sum=lamdaa,b:a+b

printsum(5,10)

Lamdaformscantakeanynumberofargumentsbutreturnjustonevalueintheformofanexpression.

Scopeofvariables

Thescopeofavariabledeterminestheportionoftheprogramwherewecanaccessaparticularvariable.

Globalscope:Avariablewithglobalscopecanbeusedanywhereintheprogramanditisdeclaredoutsideallfunctions/blocks.

Localscope:Whenavariableiscreatedinsidethefunction/block,thevariablebecomeslocaltoit.

Example3.4:Scope

x=10#globalvariable

defprintx():

y=5#localvariable

printx+y

printx

printx()

printy#NameError:name‘y’isnotdefined

Composition

Theactofjoining2ormorefunctionstogetheriscalledcomposition.

Example3.5

printmath.degrees(math.pi)

SolvedQuestions

1.DefineafunctiongetLargest(x,y)totakein2numbersandreturnthelargerofthem.

defgetLargest(x,y):

ifx>y:

returnx

returny

2.Writeapythonprogramtosimulateabasiccalculatorusingfunctionsforadd,subtract,multiplyanddivide.

defadd(x,y):

return(x+y)

defsub(x,y):

return(x-y)

defmul(x,y):

return(x*y)

defdiv(x,y):

return(x/y)

#calculatorprogram

loop=1

#thisvariableholdstheuser’schoiceinthemenu:

choice=0

whileloop==1:

print”Fourfunctioncalculator-chooseyouroption:”

print“1)Addition”,

print“2)Subtraction”,

print“3)Multiplication”,

print“4)Division”,

print“5)Quit”

choice=input(“Chooseyouroption:“)

ifchoice==1:

add1=input(”Firstnumber:“)

add2=input(”SecondNumber:“)

printadd1,“+”,add2,“=”,add(add1,add2)

elifchoice==2:

sub1=input(“Firstnumber:“)

sub2=input(“SecondNumber:“)

printsub1,“-”,sub2,“=”,sub(sub,sub2)

elifchoice==3:

mul1=input(“Firstnumber:“)

mul2=input(“SecondNumber:“)

printmul1,“*”,mul2,“=”,mul(mul1,mul2)

elifchoice==4:

div1=input(“Firstnumber:“)

div2=input(“SecondNumber:“)

printdiv1,“/”,div2,“=”,div(div1,div2)

elifchoice==5:

loop=0

print“Done!!”

Practiceproblems1. Defineafunction‘SubtractNumber(x,y)’whichtakesintwonumbersandreturnsthe

differenceofthetwo.2. Writeafunctioninpythontocalculatethepowerofagivennumber.Ifuserdoesn’t

specifytheexponentitshouldreturnthesquareofthenumber.

Chapter4:Conditionalconstructsandlooping

Controlstructureschangetheorderthatstatementsareexecutedordecideifacertainstatementwillberun.

Conditionalconstructs

Whenaprogramhasmorethanonechoiceofactionsdependingonavariable’svalueitusesaconditionalconstruct.Decisionmakingstructuresrequirethattheprogrammerspecifiescondition(s)whichifdeterminedtobetrueasetofstatementsareexecutedandifevaluatedtofalseanothersetofstatementsareexecuted.

Construct Syntax Description

If ifcondition:

Statements

Iftheconditionistrue,thendotheindentedstatements.Iftheconditionisnottrue,thenskiptheindentedstatements.

if–else ifexpression:

statement(s)

Inanif-elsestatementexactlyoneoftwopossibleindentedblocksisexecuted.

if–elif-else ifexpression1:

statement(s)

elifexpression2:

statement(s)

elifexpression3:

statement(s)

Onlyiftheprecedingifstatementisfalse,thenextifstatementisexecuted.

Example4.1:Writeaprogramtoacceptelectricitybilldetails(i.e)customernumber,customername,previousmonthmeterreadingandcurrentmonthreadingandthenfindno.ofunitsconsumedbythecustomerandamountpayabletoelectricitydepartmentbyperformingfollowingchecks:-

First100unitscostperunitisRs.4.00

Next500unitscostperunitisRs.5.00

Beyond500unitscostperunitisRs.6.00

Step1:Firstlineofaprogramisacommentdetailingthepurposeoftheprogram

#Programtocalculateelectricitybill

Step2:Weneedtogettherequiredinputfromtheuser.

name=raw_input(“Entercustomer’sname:-”)

prev=float(raw_input(“\nEnterthepreviousmonth’sreading:-”))

curr=float(raw_input(“\nEnterthecurrentmonth’sreading:-”))

Step3:Calculatingthenumberofunitsofelectricityconsumed

#Consumedunitsiscurrentmeterreading-previousmeterreading

units=curr–prev

Step4:Decidingontheformulaforamountcalculation

ifunits<=100:

bill=units*4.00;

elifunits>100andunits<500:

bill=400+(units-100)*5.00;

bill=400+2000+(units-500)*6.00;

Step5:Displayingtheoutput

print“No.ofunitsconsumed=“,units

print“Amountpayabletotheelectricitydepartment=Rs”,bill

Output:

Iterationstructures

Loopsareusedtorepeatedlyexecutethesamecodeinaprogram.Pythonhas2loops

Thegeneralsyntaxfor“for”loopis

foriteminsequence:

statement(s)

forvarinrange([start,]finish):

statement(s)

Therangefunctionusestwoargumentslikethisrange(start,finish).startisthefirstnumberthatisproduced.finishisonelargerthanthelastnumber.

Example4.2:Writeaprogramtoprintnumbersfrom0to10.

forainrange(0,10):

print(a)

Theoutputis

0123456789

Thebreakstatementbreaksoutofthesmallestenclosingfororwhileloop.Itcanbeusedtounconditionallyjumpoutoftheloop.Itterminatestheexecutionoftheloop.

Loopstatementsmayhaveanelseclause;itisexecutedwhentheloopterminatesthroughexhaustionofthelist(withfor)orwhentheconditionbecomesfalse(withwhile),

butnotwhentheloopisterminatedbyabreakstatement.ThiscanbeexplainedwithExample3.

Example4.3:Writeaprogramtoprintallprimenumbersfrom2to50usingforloop.

Weneedtodivideeachnumberbyallnumbersstartingfrom2toitself.So,ifwetake7,weneedtodivide7by2,3,4,5and6andifit’snotdivisiblebyanyofthesenumbers,thenweconcludethatit’saprimenumberandweprintitontheoutputscreen.

forninrange(2,50):

x_range=range(2,n)

forxinx_range:

ifn%x==0:

#loopfellthroughwithoutfindingafactor

print(n)

Programflow:

Let’staken=9

x_range=range(2,9)

forxinx_range:

if9%x==0:

#loopfellthroughwithoutfindingafactor

print(9)

Whenx=2

If9%2==0 � falsesocontinuetheforloop

If9%3==0 � truesobreakoutoftheloopnoneedtocheckotherfactors.9isnotaprimenumber.

Thesyntaxofthewhileloopisgivenbelow

whilecondition:

statement(s)

Thewhileloopisusedincaseswhenthestartorendofaniterationisnotknown.

Example4.4:WriteaprogramforprintingFibonacciseries.

#Fibonacciseries:

#thesumoftwoelementsdefinesthenextnumber

a,b=0,1

whileb<10:

…printb

…a,b=b,a+b

•Thefirstlinecontainsamultipleassignment:thevariablesaandbsimultaneouslygetthenewvalues0and1.Onthelastlinethisisusedagain,demonstratingthattheexpressionsontheright-handsideareallevaluated

firstbeforeanyoftheassignmentstakeplace.Theright-handsideexpressionsareevaluatedfromthelefttotheright.

•Thewhileloopexecutesaslongasthecondition(here:b<10)remainstrue.InPythonanynonzerointegervalueistrue;zeroisfalse.Theconditionmayalsobeastringorlistvalue,infactanysequence;anythingwithanon-zerolengthistrue,emptysequencesarefalse.Thetestusedintheexampleisasimplecomparison.

•Thebodyoftheloopisindented:indentationisPython’swayofgroupingstatements.

Atrailingcommaavoidsthenewlineaftertheoutput.

a,b=0,1

whileb<100:

printb,

a,b=b,a+b

Nowtheoutputwouldbe

1123581321345589

Note:Everythingthatcanbedonewithforloopscanalsobedonewithwhileloopsbutforloopsgiveaneasywaytogothroughalltheelementsinalistortodosomethingacertainnumberoftimes.

ThecontinuestatementisusedtotellPythontoskiptherestofthestatementsinthecurrentloopblockandtocontinuetothenextiterationoftheloop.Continuewillreturnbackthecontroltothebeginningoftheloop.

passdoesnothingbutmaybeusedasaplaceholderforfutureimplementation.

SolvedPrograms1. Writeaprogramtovalidatepasswordlength.

#Thisprogramgetsanewpasswordfromtheuservalidatesitslengthand

#printsanerrormessageifthepasswordenteredislessthan6characters

whileTrue:

s=raw_input(‘Enternewpassword:‘)

iflen(s)<6:

print‘Inputisofinsufficientlength’

continue

print“Passwordchangedsuccessfully”

2. Writeaprogramtoaddnumbersarbitrarilytilltheuserenters0.

print(‘EnterNumberstoaddtothesum.’)

print(‘Enter0toquit.’)

whilea!=0:

a=int(raw_input(‘Number?‘))

print‘TotalSum=‘,s

3. WriteaprograminPythontofindthesummationofthefollowingseriesusingforloops.

1+x+x2+x3+…+xn

importmath

n=int(raw_input(“Enterthevalueofn:”))

x=int(raw_input(“Enterthevalueofx:”))

foriinrange(10):

sum=sum+pow(x,i);

print”1+“,x,“+“,x,“^2+“,x,“^3+…”,x,“^”,n,”=”,sum,“\n”;

raw_input()

4. WriteaprograminPythontoconvertagivennumberfromDecimaltoBinary.

dec=int(raw_input(“Enterthedecimaltobeconverted:”))

whiledec>0:

rem=dec%2

s=s+(i*rem)

dec=dec/2

i=i*10

print“Thebinaryofthegivennumberis:”,s

raw_input()

5.Writeprogramtoinputanynumberandtoprintallfactorsofthatnumber.

n=input(“Enterthenumber”)

foriinrange(2,n):

ifn%i==0:

printi,“isafactorof”,n

6.WriteaprogramtoinputanynumberandtocheckwhethergivennumberisArmstrongornot.(Armstrong1,153,etc.13=1,13+53+33=153)

savedn=n

whilen>0:

a=n%10

sum=sum+a*a*a

n=n/10

ifsavedn==sum:

printsavedn,“isanArmstrongNumber”

printsavedn,“isnotanArmstrongNumber”

7.Writeaprogramtofindallprimenumbersuptogivennumber.

flag=0

while(i<n):

if(n%i)==0:

flag=1

printn,“iscomposite”

ifflag==0:printn,“isprime”

8.Writeaprogramtofindthesumofalldigitsofthegivennumber.

while(n>0):

a=n%10

sum=sum+a

n=n/10

print“Sumofdigits=”,sum

9.Writeaprogramtofindthereverseofanumber.

while(n>0):

a=n%10

rev=(rev*10)+a

n=n/10

print“Reversednumber=”,rev

10.Writeaprogramtoprintthepyramid.

foriinrange(1,6):

forjinrange(1,i+1):

printi,

PracticeProblems1.Writeaprogramtofindtherootsofaquadraticequation.

2. Writeaprogramtoacceptelectricitybilldetails(i.e)customernumber,customername,previousmonthmeterreadingandcurrentmonthreadingandthenfindno.ofunitsconsumedbythecustomerandamountpayabletoelectricitydepartmentbyperformingfollowingchecks:-

First100unitscostperunitisRs.4.00

Next500unitscostperunitisRs.5.00

Beyond500unitscostperunitisRs.6.00

3. WriteaprograminPythontofindthesummationofthefollowingseriesusingforloops.

1-x+x2/2!-x3/3!+…+(-1)nxn/n!

4. Writeaprogramtosimulateaguessingnumbergame.Generateanumberfrom1to100andasktheusertoguessitcorrectlywithin5tries.Aftereachguess,theprogrammusttellwhetherthenumberishigherthan,lowerthan,orequaltoyourguess.

5.Writeaprogramtoprinteveryintegerbetween1andndivisiblebym.6.Whatdoesthefollowingprintout?

foriinrange(1,10):

forjinrange(1,10):

printi*j,

7.Writeaprogramtoprintthepyramid.

Chapter5:Strings

StringsareamongstthemostpopulartypesinPython.Wecancreatethemsimplybyenclosingcharactersinquotes.Pythontreatssinglequotesthesameasdoublequotes.

Creatingstringsisassimpleasassigningavaluetoavariable.Forexample:

str1=‘HelloWorld!’

str2=“PythonProgramming”

AccessingValuesinStrings

Pythondoesnot support a character type; these are treated as stringsof lengthone,thus also considered a substring. To access substrings, we use the square brackets forslicing along with the index or indices to obtain our substring. Following is a simpleexample:

str2=“PythonProgramming”

print“str1[0]:“,str1[0]

print“str2[7:11]:“,str2[7:11]

Whentheabovecodeisexecuted,itproducesthefollowingresult:

Fig5.1:Accessingstringsoutputscreenshot

UpdatingStrings

Wecan“update”anexistingstringby(re)assigningavariable toanotherstring.Thenewvaluecanberelatedtoitspreviousvalueortoacompletelydifferentstringaltogether.Followingisasimpleexample:

str2=str1[:6]+‘Python’

print“UpdatedString:-“,str2

Fig5.2:Updatingstrings

EscapeCharacters

Followingtableisalistofescapeornon-printablecharactersthatcanberepresentedwithbackslashnotation.

An escape character gets interpreted; in a single quoted as well as double quotedstrings.

Backslashnotation

Description

\a Belloralert

\b Backspace

\cx Control-x

\C-x Control-x

\e Escape

\f Formfeed

\M-\C-x Meta-Control-x

\n Newline

\nnn Octalnotation,wherenisintherange0.7

\r Carriagereturn

\s Space

\t Tab

\v Verticaltab

\x Characterx

\xnn Hexadecimalnotation,wherenisintherange0.9,a.f,orA.F

Table5.1:Escapecharacters

StringSpecialOperators

Assumestringvariableaholds‘Hello’andvariablebholds‘Python’,then:

+ Concatenation-Addsvaluesoneithersideoftheoperator

a+bresultsinHelloPython

* Repetition-Createsnewstrings,concatenating

a*2resultsinHelloHello

multiplecopiesofthesamestring

[] Slice-Givesthecharacterfromthegivenindex

a[1]resultsine

[:] RangeSlice-Givesthecharactersfromthegivenrange

a[1:4]resultsinell

In Membership-Returnstrueifacharacterexistsinthegivenstring

Hinaresultsin1

notin Membership-Returnstrueifacharacterdoesnotexistinthegivenstring

Mnotinaresultsin1

r/R RawString-SuppressesactualmeaningofEscapecharacters.Thesyntaxforrawstringsisexactlythesameasfornormalstringswiththeexceptionoftherawstringoperator,theletter“r,”whichprecedesthequotationmarks.The“r”canbelowercase(r)oruppercase(R)andmustbeplacedimmediatelyprecedingthefirstquotemark.

printr’\n’prints\nandprintR’\n’prints\n

% Format-PerformsStringformatting

Table5.2:StringSpecialOperators

StringFormattingOperator

OneofPython’scoolestfeaturesisthestringformatoperator%.ThisoperatorisuniquetostringsandmakesupforthepackofhavingfunctionsfromC’sprintf()family.Followingisasimpleexample:

print“Mynameis%sandweightis%dkg!”%(‘Tara’,50)

Fig5.3:formattingusing%

Hereisthelistofcompletesetofsymbolswhichcanbeusedalongwith%:

FormatSymbol

Conversion

%c Character

%s stringconversionviastr()priortoformatting

%i signeddecimalinteger

%d signeddecimalinteger

%u unsigneddecimalinteger

%o octalinteger

%x hexadecimalinteger(lowercaseletters)

%X hexadecimalinteger(UPPERcaseletters)

%e exponentialnotation(withlowercase‘e’)

%E exponentialnotation(withUPPERcase‘E’)

%f floatingpointrealnumber

%g theshorterof%fand%e

%G theshorterof%fand%E

Table5.3:formatsymbols

Built-instringfunctions

Pythonincludesthefollowingbuilt-inmethodstomanipulatestrings:

SNo Methods Description Example

1 capitalize()

Capitalizesfirstletterofstring

str=“hellopython“

printstr.capitalize()

Hellopython

2 endswith(suffix,beg=0,end=len(string))

Determinesifstringorasubstringofstring(ifstartingindexbegandendingindexendaregiven)endswithsuffix;

Computer”.endswith(“er”)

returnstrueifsoandfalseotherwise

3 find(str,beg=0end=len(string))

Determineifstroccursinstringorinasubstringofstringifstartingindexbegandendingindexendaregivenreturnsindexiffoundand-1otherwise

str=‘Computer’

printstr.find(‘put’)

#Onomittingthestartparameters,thefunctionstartsthesearchfrom

#thebeginning.

printstr.find(‘put’,2)

printstr.find(‘put’,1,3)

#Displays-1becausethesubstringcouldnotbefoundbetweentheindex1and3-1

4 index(str,beg=0,end=len(string))

Sameasfind(),butraisesanexceptionifstrnotfound

“Computer”.index(‘pat’)

Traceback(mostrecentcalllast):

File“<pyshell#1>”,line1,in<module>

“Computer”.index(‘pat’)

ValueError:substringnotfound

5 isalnum()

Returnstrueifstringhasatleast1characterandallcharactersarealphanumericandfalse

str=‘HelloPython’

printstr.isalnum()

#ThefunctionreturnsFalseasspaceisanalphanumericcharacter.

otherwise print“Python123”.isalnum()

6 isalpha()

Returnstrueifstringhasatleast1characterandallcharactersarealphabeticandfalseotherwise

print‘Python123’.isalpha()

print‘python’.isalpha()

7 isdigit()

Returnstrueifstringcontainsonlydigitsandfalseotherwise

str=‘1234’

printstr.isdigit()

8 islower()

Returnstrueifstringhasatleast1casedcharacterandallcasedcharactersareinlowercaseandfalseotherwise

print‘HELLOpython’.islower()

hellopython

9 isnumeric()

Returnstrueifaunicodestringcontainsonlynumericcharactersandfalseotherwise

str=u”year2013”

printstr.isnumeric()

10 isspace()

Returnstrueifstringcontainsonlywhitespace

str=’‘

printstr.isspace()

charactersandfalseotherwise

11 istitle()

Returnstrueifstringisproperly“titlecased”andfalseotherwise

print‘HelloWorld’.istitle()

12 isupper()

Returnstrueifstringhasatleastonecasedcharacterandallcasedcharactersareinuppercaseandfalseotherwise

print“‘HELLOpython’.isupper()

13 join(seq)

Merges(concatenates)thestringrepresentationsofelementsinsequenceseqintoastring,withseparatorstring

str1=(‘10’,‘oct’,‘2013’)

str=”-”

printstr.join(str1)

10-oct-2013

14 len(string)

Returnsthelengthofthestring

len(“Computer”)

15 lower()

Convertsalluppercaselettersinstringtolowercase

“OpticalFibre”.lower()

‘opticalfibre’

16 lstrip()

Removesallleadingwhitespaceinstring

”Python“.lstrip()

‘Python‘

17 max(str)

Returnsthemaxalphabeticalcharacterfromthestringstr

max(“Python”)

‘y’

18 min(str)

Returnstheminalphabeticalcharacterfromthestringstr

min(“Python”)

‘P’

19 replace(old,new[,max])

Replacesalloccurrencesofoldinstringwithneworatmostmaxoccurrencesifmaxgiven

“C++isapowerfullanguage”.replace(“C++”,“Python”)

‘Pythonisapowerfullanguage’

20 rfind(str,beg=0,end=len(string))

Sameasfind(),butsearchbackwardsinstring

“PythonProgram”.rfind(“P”)

21 rindex(str,beg=0,end=len(string))

Sameasindex(),butsearchbackwardsinstring

“PythonProgram”.rindex(“P”)

22 rstrip()

Removesalltrailingwhitespaceofstring

”Python“.rstrip()

‘Python’

23 split(str=””,num=string.count(str))

Splitsstringaccordingtodelimiterstr(spaceifnotprovided)andreturnslistofsubstrings;splitintoatmostnumsubstringsifgiven

“1:Anand-2:Babu-3:Charles-4:Dravid”.split(‘-‘)

[‘1:Anand’,‘2:Babu’,‘3:Charles’,‘4:Dravid’]

24 splitlines(num=string.count(‘\n’))

Splitsstringatall(ornum)NEWLINEsandreturnsalistofeachlinewithNEWLINEsremoved

“1:Anu-\n2:Banu-\n3:Charles-\n4:David”.splitlines(3)

[‘1:Anu-\n’,‘2:Banu-\n’,‘3:Charles-\n’,‘4:David’]

25 startswith(str,beg=0,end=len(string))

Determinesifstringorasubstringofstring(ifstartingindexbegandendingindexendaregiven)startswithsubstringstr;returnstrueifsoandfalse

“Pythonisafreesoftware…….”.startswith(“Python”)

otherwise

26 strip([chars])

Performsbothlstrip()andrstrip()onstring

“Python“.strip()

‘Python’

27 swapcase()

Invertscaseforalllettersinstring

“pythonPROGRAMMING”.swapcase()

‘PYTHONprogramming’

28 title()

Returns“titlecased”versionofstring,thatis,allwordsbeginwithuppercaseandtherestarelowercase

“pythonPROGRAMMING”.title()

‘PythonProgramming’

29 upper()

Convertslowercaselettersinstringtouppercase

“python”.upper()

‘PYTHON’

30 zfill(width)

Returnsoriginalstringleftpaddedwithzerostoatotalofwidthcharacters;intendedfornumbers,zfill()retainsanysigngiven(lessone

“1234”.zfill(10)

‘0000001234’

Table5.4:Built-instringfunctions

Stringconstants

Constant Description Example

string.ascii_uppercase

Thecommanddisplaysastringcontaininguppercasecharacters.

>>>string.ascii_uppercase

‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’

string.ascii_lowercase

Thecommanddisplaysastringcontainingalllowercasecharacters.

>>>string.ascii_lowercase

‘abcdefghijklmnopqrstuvwxyz’

string.ascii_letters

Thecommanddisplaysastringcontainingbothuppercaseandlowercasecharacters.

>>>string.ascii_letters

‘abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’

string.digits

Thecommanddisplaysastringcontainingdigits.

>>>string.digits

‘0123456789’

string.hexdigits

Thecommanddisplaysastringcontaininghexadecimalcharacters.

>>>string.hexdigits

‘0123456789abcdefABCDEF’

string.octdigits

Thecommanddisplaysastringcontainingoctalcharacters

>>>string.octdigits

‘01234567’

string.punctuations

Thecommanddisplaysastringcontainingallthepunctuationcharacters.

>>>string.punctuations

‘!”#$%&'()*+,-./:;<=>?@[\]^_`{|}-‘

string.whitespace

ThecommanddisplaysastringcontainingallASCIIcharactersthatareconsidered

whitespace.Thisincludesthecharactersspace,tab,linefeed,return,formfeed,andverticaltab.

>>>string.whitespace

‘\t\n\x0b\x0c\r‘

string.printable

Thecommanddisplaysastringcontainingallcharacterswhichare

>>>string.printable

‘0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!

“#$%&'()*+,-./:;<=>?@[\]^_`{|}-\t\n\r\x0b\x0c’

consideredprintablelikeletters,digits,punctuationsandwhitespaces.

Table5.6:stringconstants

Example5.1:Writeaprogramtocheckwhetherthestringisapalindromeornot.

defpalin():

str=input(“EntertheString”)

l=len(str)

index=0

while(index<p):

if(str[index]==str[p]):

index=index+1

print“Stringisnotapalindrome”

print“StringisaPalindrome”

Executionsteps:

Fig5.4:Palindromeexecutionsteps

Output:

StringisaPalidrome

RegularexpressionsandPatternmatching

Aregularexpressionisasequenceoflettersandsomespecialcharacters(alsocalledmetacharacters).Thesespecialcharactershavesymbolicmeaning.Thesequenceformedbyusingmetacharactersandletterscanbeusedtorepresentagroupofpatterns.

Regularexpressionscanbeusedinpythonformatchingaparticularpatternbyimportingtheremodule.

Note:remoduleincludesfunctionsforworkingonregularexpression.

Thefollowingtableexplainshowthemetacharactersareusedtoformregularexpressions.

S.No MetaCharacter Usage Example

1 [] Usedtomatchasetofcharacters

[star]

Theregularexpression

wouldmatchanyofthe

characterss,t,aorr.

wouldmatchonly

lowercasecharacters.

2 ^ Usedtocomplementingasetofcharacters

[^star]

wouldmatchanyother

charactersthans,t,aorr.

3 $ Usedtomatchtheendofstringonly

wouldmatchStarin

BlueStarbutwillnotmatch

StarinStardom

4 * Usedtospecifythatthepreviouscharactercanbematchedzeroormoretimes.

wouldmatchstringslike

Bye,Blue,Beeandsoon.

5 + Usedtospecifythatthepreviouscharactercanbematchedoneormoretimes.

TheregularexpressionwouldmatchstringslikeBeer,Baarandsoon.

6 ? Usedtospecifythatthepreviouscharactercanbematchedeither

onceorzerotimes

TheregularexpressionwouldonlymatchstringslikeBarorBear

7 {} Thecurlybracketsaccepttwointegervalues.Thefirstvalue

specifiestheminimumnoofoccurrencesandsecondvaluespecifiesthemaximumof

occurrences

wate{1,4}r

wouldmatchonlystrings

water,wateer,wateeeror

wateeeer

Table5.7:metacharacters

Functionsfromremodule

Function Description

re.compile()

compilethepatternintopatternobjects.Afterthecompilationthepatternobjectswillbeabletoaccessmethodsforvariousoperationslikesearchingandsubstitutions

re.match()

Thematchfunctionisusedtodetermineiftheregularexpression(RE)matchesatthebeginningofthestring.

re.group()

ThegroupfunctionisusedtoreturnthestringmatchedtheRE

re.start()

Thestartfunctionreturnsthestartingpositionofthematch.

re.end()

Theendfunctionreturnstheendpositionofthematch.

re.span()

Thespanfunctionreturnsthetuplecontainingthe(start,end)positionsofthematch

re.search()

ThesearchfunctiontraversesthroughthestringanddeterminesthepositionwheretheREmatchesthestring

re.findall()

ThefunctiondeterminesallsubstringswheretheREmatches,andreturnsthemasalist.

re.finditer()

ThefunctiondeterminesallsubstringswheretheREmatches,andreturnsthemasaniterator.

Table5.8:functionsinremodule

Example5.2:Demonstrationofrefunctions

importre

P=re.compile(“hell*o”)

m=re.match(“hell*o”,“hellooooopython”)

printm.group()

m=re.match(‘hell*o’,‘hellooooopython’)

printm.start()

printm.end()

printm.span()

m=re.search(‘hell*o’,‘hellooopython’)

printm

m=re.findall(‘hell*o’,‘hellohelloopython’)

printm

SolvedPrograms1. Writeaprogramtocountnoof‘s’inthestring‘mississippi’.

deflettercount():

word=‘mississippi’

count=0

forletterinword:

ifletter==‘s’:

count=count+1

print(count)

2. Writeaprogramthatreadsastringanddisplaythelongestsubstringofthegivenstringhavingjusttheconsonants.

string=raw_input(‘‘Enterastring:’’)

length=len(string)

maxlength=0

maxsub=‘’

sub=‘’

lensub=0

forainrange(length):

ifstring[a]in‘aeiou‘orstring[a]in‘AEIOU’:

iflensub>maxlength:

maxsub=sub

maxlength=lensub

sub=‘’

lensub=0

sub+=string[a]

lensub=len(sub)

print‘‘Maximumlengthconsonentsubstringis:’’,maxsub,

print‘‘with’’,maxlength,‘‘characters’’

3.Writeaprogramtodetermineifthegivensubstringispresentinthestring.

importre

substring=‘Rain’

search1=re.search(substring,‘RainRaingoaway!’)

ifsearch1:

position=search1.start()

print“matched”,substring,“atposition”,position

print“Nomatchfound”

4.Writeaprogramtodetermineifthegivensubstring(definedusingmetacharacters)ispresentinthegivenstring

importre

p=re.compile(‘dance+’)

search1=re.search(p,‘WesterndancersdanceforEnglishmusicwell’)

ifsearch1:

match=search1.group()

print“matched=”,match

index=search1.start()

print“atposition”,index

print“Nomatchfound”

5.WritePythonscriptthattakesastringwithmultiplewordsandthencapitalizesthefirstletterofeachwordandformsanewstringoutofit.

string=raw_input(‘‘Enterastring:’’)

length=len(string)

end=length

string2=‘’#emptystring

whilea<length

ifa==0

string2+=string[0].upper()a+=1

elif(string[a]==‘’andstring[a+1)!=‘’):

string2+=string[a]

string2+=string[a+1].upper()a+=2

string2+=string[a]

print‘‘Originalstring:’’,string

print‘‘Convertedstring:’’,string2

6.Whichstringmethodisusedtoimplementthefollowing?

a)Tocountthenumberofcharactersinthestring.

b)Tochangethefirstcharacterofthestringincapitalletter.

c)Tocheckwhethergivencharacterisletteroranumber.

d)Tochangelowercasetouppercaseletter.

e)Changeonecharacterintoanothercharacter.

a)len(str)

b)str.title()orstr.capitalize()

c)str.isalphaandstr.isdigit()

d)lower(str[i])

e)str.replace(char,newchar)

7.Writeaprogramtoinputanystringandtofindnumberofwordsinthestring.

str=“Honestyisthebestpolicy”

words=str.split()

printlen(words)

8.Considerthestringstr=”AFriendIndeed”.WritestatementsinPythontoimplementthefollowing

a)Todisplaythelastfourcharacters.

b)Todisplaythesubstringstartingfromindex4andendingatindex8.

c)Tocheckwhetherstringhasalphanumericcharactersornot.

d)Totrimthelastfourcharactersfromthestring.

e)Totrimthefirstfourcharactersfromthestring.

f)Todisplaythestartingindexforthesubstring“end”.

g)Tochangethecaseofthegivenstring.

h)Tocheckifthestringisintitlecase.

i)Toreplacealltheoccurrencesofletter‘e’inthestringwith‘*’?

a)str[-4:]

b)str[4:8]

c)str.isalnum()

d)str=str[4:]

e)str=str[-4:]

f)str.find(“end”)

g)str.swapcase()

h)str.istitle()

i)str.replace(‘e’,’*’)

PracticeProblems

1.WriteaprograminPythontocountthenumberofvowelsinagivenword.

2.WriteaprogramusingregularexpressionsinPythontovalidatepasswordsinagivenlistofpasswords.

3.Writeaprogramtopartitionthestringattheoccurrenceofagivenletter.

4.WriteaprograminPythontosortagivenarrayofstudentnamesinalphabeticalorder.

5.Considerthestringstr=”HelloPython”.Writestatementsinpythontoimplementthefollowing

a)Todisplaythelastsixcharacters.

b)Todisplaythesubstringstartingfromindex2andendingatindex6

c)Tocheckwhetherstringhasalphanumericcharactersornot.

d)Totrimthelastsixcharactersfromthestring.

e)Totrimthefirstsixcharactersfromthestring.

f)Tochangethecaseofthegivenstring.

g)Tocheckifthestringisintitlecase.

Chapter6:Lists

ListsarethesimplestdatastructureinPythonandareusedtostorealistofvalues.Listsarecollectionsofitems(strings,integers,orevenotherlists).Eachiteminthelisthasanassignedindexvalue.Listsareenclosedin[].Eachiteminalistisseparatedbyacomma.Unlikestrings,listsaremutable,whichmeanstheycanbechanged.

Listoperations

Creation

Listsarecreatedusingacommaseparatedlistofvaluessurroundedbysquarebrackets.Listsholdasequenceofvalues.Listsareveryeasytocreate,thesearesomeofthewaystomakelists.

L=[]#Anemptylistiscreatedusingonlysquarebrackets

list1=[‘one’,‘two’,‘three’,‘four’,‘five’]

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

Length

Withthelengthfunctionwecangetthelengthofalist

list=[“1”,“hello”,2,“world”]

len(list)

Append

Listappendwilladdtheitemattheend.list.append(x)willaddanelementtotheendofthelist

list=[‘Python’,‘Java’,‘C++’]

list.append(‘C’)

printlist

[‘Python’,‘Java’,‘C++’,‘C’]

Insert

Ifwewanttoaddatthebeginningormiddle,wecanusetheinsertfunction.

list.insert(0,“HTML”)

printlist

[‘HTML’,‘Python’,‘Java’,‘C++’,‘C’]

list.insert(3,“VB”)

printlist

[‘HTML’,‘Python’,‘Java’,‘VB’,‘C++’,‘C’]

Remove

Toremoveanelement’sfirstoccurrenceinalist,simplyuselist.remove.Thesyntaxis:list.remove(x).xcanbetheitemname.xcanalsobeanumber.

list=[‘HTML’,‘Python’,‘Java’,‘VB’,‘C++’,‘C’]

list.remove(“Java”)

printlist

[‘HTML’,‘Python’,‘VB’,‘C++’,‘C’]

list=[1,2,3,4]

list.remove(2)

printlist

[1,3,4]

Delete

Weusedeltoremoveitembasedonindexposition.

list=[‘HTML’,‘Python’,‘Java’,‘VB’,‘C++’,‘C’]

dellist[1]

printlist

HTML,Java,VB,C++,C

Extend

Itjoinsalistwithanother list2=[“Javascript”,“VBScript”]

list.extend(list2)

printlist

[‘HTML’,‘VB’,‘C++’,‘C’,‘Javascript’,‘VBScript’]

In Thekeyword“in”canbeusedtotestifanitemisinalist.

list=[“red”,“orange”,“green”,“blue”]

if“red”inlist:

print“redispresentinlist”

redispresentinlist

Keyword“not”canbecombinedwith“in”.

list=[“red”,“orange”,“green”,“blue”]

if“purple”notinlist:

print“purplenotinlist”

purplenotinlist

Reverse

Thereversemethodreversestheorderoftheentirelist.

#Toprintareverselist

L=[10,20,40]

foriinlist[::-1]:

printi

L.reverse()

printL

[40,20,10]

Sorting

Ittakesalistandreturnsanewlistwiththoseelementsinsortedorder.Theoriginallistisnotchanged.Thesorted()functioncanbecustomizedthoughoptionalarguments.Thesorted()optionalargumentreverse=True,e.g.sorted(list,reverse=True),makesitsortbackwards.

#createalistwithsomenumbersinit

numbers=[5,1,4,3,2,6,7,9]

#printsthenumberssorted

printsorted(numbers)

#theoriginallistofnumbersarenotchanged

printnumbers

[1,2,3,4,5,6,7,9]

Spliteachelementinalist

list=‘one,two,three,four,five’

newlist=list.split(‘,’)

printnewlist

[‘one’,‘two’,‘three’,‘four’,‘five’]

Indexing

Eachiteminthelisthasanassignedindexvaluestartingfrom0.Accessingelementsinalistiscalledindexing.

list=[“apple”,“banana”,“mango”]

list[0]==“apple”

list[1]==“banana”

list[2]==“mango”

Slicing

Accessingpartsofsegmentsiscalledslicing.Listscanbeaccessedjustlikestringsbyusingthe[]operators.Thekeypointtorememberisthatthe:endvaluerepresentsthefirstvaluethatisnotintheselectedslice.So,thedifferencebetweenendandstartisthenumberofelementsselected(ifstepis1,thedefault).

Let’screatealistwithsomevaluesinit

colors=[‘yellow’,‘red’,‘blue’,‘green’,‘black’]

printcolors[0]

Yellow

printcolors[1:]

red,blue,green,black

a[start:end]#itemsstartthroughend-1

a[start:]#itemsstartthroughtherestofthearray

a[:end]#itemsfromthebeginningthroughend-1

a[:]#acopyofthewholearray

Thereisalsothestepvalue,whichcanbeusedwithanyoftheabove

a[start:end:step]#startthroughnotpastend,bystep

Negativeindexing

Theotherfeatureisthatstartorendmaybeanegativenumber,whichmeansitcountsfromtheendofthearrayinsteadofthebeginning.

a[-1]#lastiteminthearray

a[-2:]#lasttwoitemsinthearray

a[:-2]#everythingexceptthelasttwoitems

Callstolistmethodshavethelisttheyoperateonappearbeforethemethodname.Anyothervaluesthemethodneedstodoitsjobisprovidedinthenormalwayasanextraargumentinsidetheroundbrackets.

Thefollowingfigurehelpstodemonstratenegativeindices

Listfunctions

S.No Function Description

1 cmp(list1,list2) Compareselementsofbothlists.

2 len(list) Givesthetotallengthofthelist.

3 max(list) Returnsitemfromthelistwithmaxvalue.

4 min(list) Returnsitemfromthelistwithminvalue.

5 list(seq) Convertsatupleintolist.

6 list.append(obj) Appendsobjectobjtolist

7 list.count(obj) Returnscountofhowmanytimesobjoccursinlist

8 list.extend(seq) Appendsthecontentsofseqtolist

9 list.index(obj) Returnsthelowestindexinlistthatobjappears

10 list.insert(index,obj) Insertsobjectobjintolistatoffsetindex

11 list.pop(obj=list[-1]) Removesandreturnslastobjectorobjfromlist

12 list.remove(obj) Removesobjectobjfromlist

13 list.reverse() Reversesobjectsoflistinplace

14 list.sort([func]) Sortsobjectsoflist,usecomparefuncifgiven

Table6.1:Summaryoflistfunctionsandmethods

Matrices

Amatrixisagrid,witheachlocationinthegridcontainingsomeinformation.Considertheexcelsheet.Amatrixhasrowsandcolumnsandeachelementisinsideacell.Touniquelyidentifytheelementweusetherownameandcolumnname.

Fig6.1:Matrix–excel

Toaccess“2”,wesayB1inSpreadsheet,whereBisthecolumnheaderand1istherow.Inacomputer,westorethematrixandaccesstheelementsusingindices.

0 1 2 3

1 4 5 6

Fig6.2:Matrix–2DArray

Toaccess“2”,wesay[0][1].

Matriximplementationusinglist

Wecanimplementmatrixoperationusinglist.Matrixoperationcanbeimplementedusingnestedlist.Listinsideanotherlistiscallednestedlist.

Asafirststep,weneedtogetthenumberofrowsandcolumns.

m=int(raw_input(“Entertotalnumberofrows”))

n=int(raw_input(“Entertotalnumberofcolumns”))

Afterthatwecancreateamatrixnameda,asstatedbelow.

a=[[random.random()forrowinrange(m1)]forcolin

range(n1)]

Weneedtoimportrandomfile.Thisstepgeneratesamatrixliketheonelistedbelowifweentervaluesfornumberofrowsandcolumnsas2.Itisalsofilledwithsomerandomvaluesasshowninfigbelow.

0.314 0.678

0.191 0.567

Fig6.3:List-Initialstate

Wecanfillthematrixwithvaluesfromtheuser.

foriinrange(m):

forjinrange(n):

l[k]=int(raw_input((“Enterelement”)))

Fig6.4:List-withvalues

Finally,wecanprintthevalueswiththebelowcode.

foriinrange(m):

forjinrange(n):

printl[k],‘\t’,

Example6.1:WriteaprogramtoinputanymatrixwithmXn,andprintthenumberontheoutputscreeninmatrixformat.

l=range(m*n)

print“Inputallmatrixelementsoneafterother”

foriinrange(m):

forjinrange(n):

l[k]=int(raw_input((“Enternewelement”)))

print“outputis”

foriinrange(m):

forjinrange(n):

printl[k],‘\t’,

SolvedQuestions1. Writeaprogramtouselistfunctionstosortalistandfindthemaximumand

minimummarksinaclass.

print“EnterNumberofMarks:“,

maxrange=0

maxrange=input()

marks=[]

foriinrange(0,maxrange):

marks.append(input())

#Sortthemarks

marks.sort()

printmarks[i]

print“Highestscoreis”,max(marks)

print“Lowestscoreis”,min(marks)

print“ClassAverageis”,sum(marks)/maxrange

2. Writeaprogramtoinputanytwomatricesandprintsumofmatrices.

importrandom

m1=int(raw_input(“Entertotalnumberofrowsinthefirstmatrix”))

n1=int(raw_input(“Entertotalnumberofcolumnsinthefirstmatrix”))

a=[[random.random()forrowinrange(m1)]forcolinrange(n1)]

foriinrange(m1):

forjinrange(n1):

a[i][j]=int(raw_input(“?“))

b=[[random.random()forrowinrange(m2)]forcolinrange(n2)]

foriinrange(m2):

forjinrange(n2):

b[i][j]=int(raw_input(“?“))

c=[[random.random()forrowinrange(m1)]forcolinrange(n1)]

if((m1==m2)and(n1==n2)):

print“outputis”

foriinrange(m1):

forjinrange(n1):

c[i][j]=a[i][j]+b[i][j]

printc[i][j],‘\t’,

print“Matrixadditionnotpossible”

3.Writeaprogramtoinputanytwomatricesandprintproductofmatrices.

importrandom

a=[[random.random()forrowinrange(m1)]forcolinrange(n1)]

foriinrange(m1):

forjinrange(n1):

a[i][j]=int(raw_input(“?“))

m2=input(“Entertotalnumberofrowsinthesecondmatrix”)

n2=input(“Entertotalnumberofcolumnsinthesecondmatrix”)

b=[[random.random()forrowinrange(m2)]forcolinrange(n2)]

foriinrange(m2):

forjinrange(n2):

b[i][j]=int(raw_input(“?“))

c=[[random.random()forrowinrange(m1)]forcolinrange(n2)]

if(n1==m2):

foriinrange(m1):

forjinrange(n2):

c[i][j]=0

foriinrange(m1):

forjinrange(n2):

forkinrange(n1):

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

printc[i][j],‘\t’,

print“Multiplicationnotpossible”

4.Writeaprogramtoinputanymatrixandprintbothdiagonalvaluesofthematrix.

l=range(m*n)

print“Inputallmatrixelementsoneafterother”

foriinrange(m):

forjinrange(n):

l[k]=int(raw_input((“Enternewelement”)))

print“leftdiagonal”

foriinrange(m):

forjinrange(n):

ifi==j:

printl[k],‘\t’,

print‘\t’,

print“rightdiagonal”

foriinrange(m):

forjinrange(n):

if(i+j)==(m-1):

printl[k],‘\t’,

print‘\t’,

5. Writeaprogramtopassanylistandtoarrangeallnumbersindescendingorder.

defarrange(l,n):

foriinrange(n-1):

forjinrange(n-i-1):

ifl[j]<l[j+1]:

temp=l[j]

l[j]=l[j+1]

l[j+1]=temp

defmain():

l=[7,5,8,2,9,10,3]

arrange(l,len(l))

printl

if__name__==“__main__”:

main()

Practiceproblems1. Writeaprogramtocalculateanddisplaythesumofalltheoddnumbersinthelist.2. Writeaprogramforfindingamatrixrowsum,columnsumanddiagonalsum.3. Defineafunctionoverlapping()thattakestwolistsandreturnsTrueiftheyhaveat

leastonememberincommon,Falseotherwise.4. Writetheoutputfromthefollowingcode:

A=[20,40,60,80,100]

L=len(A)

forIinrange(1,L,2):

S+=A[I]

print“Sum=”,S

5.Findtheerrorsfromthefollowingprogram

n=int(raw_input(“Entertotalnumberofelements”))

l=range(n)

printl

foriin(n):

l[i]=raw_input(“enterelement”)

print“Allelementsinthelistontheoutputscreen”

forionrange(n):

printl[i]

6.Writeafunctiontofindallduplicatesinthelist.

Chapter7:DICTIONARIES

Adictionaryislikealist.Inalist,indexvalueisaninteger,whileinadictionaryindexvaluecanbeanyotherdatatypeandarecalledkeys.

AdictionaryismutableandisanothercontainertypethatcanstoreanynumberofPythonobjects,includingothercontainertypes.Adictionaryisanextremelyusefuldatastorageconstructforstoringandretrievingallkeyvaluepairs,whereeachelementisaccessed(orindexed)byauniquekey.

Dictionariesconsistofpairs(calleditems)ofkeysandtheircorrespondingvalues.Pythondictionariesarealsoknownasassociativearraysorhashtables.Wecanrefertoadictionaryasamappingbetweenasetofindices(whicharecalledkeys)andasetofvalues.Eachkeymapsavalue.Theassociationofakeyandavalueiscalledakey-valuepair.

Creatingadictionary

Eachkeyisseparatedfromitsvaluebyacolon(:),theitemsareseparatedbycommas,andthewholethingisenclosedincurlybraces.Anemptydictionarywithoutanyitemsiswrittenwithjusttwocurlybraces,likethis:{}.

Keys are unique within a dictionary while values may not be. The values of adictionary canbeof any type, but thekeysmust beof an immutabledata type such asstrings,numbers,ortuples.

Thegeneralsyntaxofadictionaryisasfollows:

dict-name={key1:value1,key2:value2….}

Example7.1:Let’screateadictionarythatmapsfromnumberstonumbernames,sothekeysvaluesareinnumbersandvaluesareinstrings.

A={1:“One”,2:“Two”,3:“Three”}

printA

Wecanalsocreateadictionarywithkeywordargumentsandthetypeconstructor,aslongasthekeysareallstrings.

bob=dict(name=‘BobSmith’,age=42,pay=30000,job=‘developer’)

sam=dict(name=‘SamuelRichard’,age=45,pay=40000,job=‘manager’)

printbob

printsam

Fig7.2:Creatingdictionary2

Wecanalsofillthedictionaryonefieldatatime.

pam={}

pam[‘name’]=‘PamelaJones’

pam[‘age’]=45

pam[‘pay’]=40000

pam[‘job’]=‘Clerk’

printpam

Fig7.3:Creatingdictionary3

CharacteristicsofPythonDictionaries

1.DictionariesareUnordered

Thedictionaryelements(key-valuepairs)arenotinorderedform.

A={1:“One”,2:“Two”,3:“Three”,6:“Six”,4:“Four”,5:“Five”}

printA

Fig7.4:Dictionary-unordered

Theorderofelementswhilethedictionarywasbeingcreatedisdifferentfromtheorderinwhichtheyareactuallystoredanddisplayed.Evenifotherelementsareaddedtothepythondictionary,theorderisnotpreserved.

2.DictionaryKeysareCaseSensitive

Thesamekeynamebutwithdifferentcasearetreatedasdifferentkeysinpythondictionaries.

worddict={}#Createanemptydictionary

worddict[“Raja”]=123233

worddict[“Rama”]=123456

worddict[“rama”]=123789

printworddict

Fig7.5:Dictionary–casesensitive

Intheexampleabove,separateelementsfor“Rama”and“rama”arecreated.

3.Noduplicatekeyisallowed

When duplicate keys encountered during assignment, the last assignment wins.Followingisasimpleexample:

phonebook={“Harry”:856321900,“Henry”:893456782,“Sony”:678903421}

printphonebook

print“DuplicatingkeySony”

phonebook[“Sony”]=900235000

printphonebook

Fig7.6:Dictionary–noduplicatekey

4.Keysmustbeimmutable

Wecanusestrings,numbersortuplesasdictionarykeysbutsomethinglike[‘key’]isnotallowed.Followingisasimpleexample:

phonebook={[‘Name’]:‘Harry’,‘Age’:50}

print“phonebook[‘Name’]:”,phonebook[‘Name’]

Fig7.7:Dictionary–immutablekeys

AccessingValuesinDictionary

To access dictionary elements, square brackets along with the key are used toobtainitsvalue.

printA

print“A[2]=”,A[2]

print“A[5]=”,A[5]

Fig7.8:Accessingvaluesindictionary

Ifweattempttoaccessadataitemwithakey,whichisnotpartofthedictionary,wegetanerrorasfollows:

printA

print“A[10]=”,A[10]

Fig7.9:AccessError–wrongkey

UpdatingDictionary

Anexistingentrycanbemodifiedbyreassigninganewvaluetothekey.

printphonebook

name=raw_input(“Enternametomodify:“)

ifnameinphonebook:

newno=raw_input(“Enternewtelephonenumber”)

phonebook[name]=newno

print“Modifiedsuccessfully”

print(name,“wasnotfound”)

Fig7.10:Updatingdictionary

DeleteDictionaryElements

We can remove individual dictionary elements or clear the entire contents of adictionary.

printphonebook

name=raw_input(“Enternametodelete:“)

ifnameinphonebook:

delphonebook[name]

printname,“deletedsuccessfully”

printphonebook

Fig7.11:Deletingdictionaryelements

Wecanalsodeleteentiredictionaryinasingleoperationusingthedelstatement.

printphonebook

delphonebook

print“Phonebookdeletedsuccessfully”

printphonebook

Fig7.12:Deletingdictionary

Built-inDictionaryFunctions&Methods

Python includes the following dictionary functions. For all these examples let’sassume

phonebook1={“Harry”:856321900,“Henry”:893456782,“Sony”:678903421}

1 cmp(dict1,dict2)

Thisisusedtocheckwhetherthegivendictionariesaresameornot.Ifbotharesame,itwillreturn‘zero’,otherwisereturn1or-1.Ifthefirstdictionaryhavingmorenumberofitems,thenitwillreturn1,otherwisereturn-1.

phonebook2={“Harry”:878345123,“Raja”:987652341,“Sriya”:908765432}

printcmp(phonebook1,phonebook2)

2 len(dict)

Givesthetotallengthofthedictionary.Thiswouldbeequaltothenumberofitemsinthedictionary.

printlen(phonebook1)

3 str(dict)

Producesaprintablestring

printstr(phonebook1)

>>{‘Sony’:678903421,‘Henry’:

representationofadictionary

893456782,‘Harry’:856321900}

4 type(variable)

Returnsthetypeofthepassedvariable.Ifpassedvariableisdictionary,thenitwouldreturnadictionarytype.

printtype(phonebook1)

>><type‘dict’>

Table7.1:PythonDictionaryFunctions

Pythonincludesfollowingdictionarymethods

S.No Methods Description Example

1 dict.clear()

Itremovesallitemsfromtheparticulardictionarydict.

phonebook1.clear()

printphonebook1

2 dict.copy()

Returnsashallowcopyofdictionarydict

phonebook2=phonebook1.copy()

printphonebook2

>>{‘Sony’:678903421,‘Harry’:856321900,‘Henry’:893456782}

3 dict.fromkeys()

Createanewdictionarywithkeysfromseqandvaluessettovalue.

printphonebook1.fromkeys(“Harry”)

>>{‘a’:None,‘H’:None,‘r’:None,‘y’:None}

4 dict.get(k,default=None)

Thefirstargumentiskey

printphonebook1.get(‘Harry’,“HarryPotter”)

value,whilethesecondargumentiscorrespondingvalue.Ifadictionaryhasagivenkey(k),whichisequaltogivenvalue(x),itreturnsthecorrespondingvalue(x)ofgivenkey(k).However,ifthedictionaryhasnokey-valuepairforgivenkey(k),thismethodreturnsthedefaultvaluessameasgivenkeyvalue.Thesecondargumentisoptional.Ifomittedandthedictionaryhasnokeyequaltothegivenkeyvalue,thenitreturnsNone.

>>856321900

printphonebook1.get(“Harry”,“Henry”)

>>856321900

printphonebook1.get(“Harry”)

>>856321900

printphonebook1.get(“Rita”)

>>None

5 dict.has_key(key)

Thisfunctionreturns‘True’,ifdictionaryhasakey,otherwiseitreturns‘False’.

printphonebook1.has_key(“Harry”)

>>True

6 dict.items() Itreturnsthe printphonebook1.items()

contentofdictionaryasalistofkeyandvalue.Thekeyandvaluepairwillbeintheformofatuple,whichisnotinanyparticularorder.

>>[(‘Sony’,678903421),(‘Henry’,893456782),(‘Harry’,856321900)]

7 dict.keys()

Itreturnsalistofthekeyvaluesinadictionary,whichisnotinanyparticularorder.

printphonebook1.keys()

>>[‘Sony’,‘Henry’,‘Harry’]

8 dict.setdefault(key,default=None)

Similartoget(),butwillsetdict[key]=defaultifkeyisnotalreadyindict

phonebook1={‘name’:‘John’,‘phone’:12390007}

printphonebook1.setdefault(‘phone’,None)

>>12390007

9 dict.update(dict2)

Addsdictionarydict2’skey-valuespairstodict

printphonebook1.update(phonebooknew)

printphonebook1

>>{‘Sony’:678903421,‘Henry’:893456782,‘Huges’:954005678,‘Harry’:856321900}

10 dict.values()

Itreturnsalistofvaluesfromkey-valuepairsina

printphonebook1.values()

>>[678903421,893456782,954005678,856321900]

dictionary,whichisnotinanyparticularorder.However,ifwecallboththeitems()andvalues()methodwithoutchangingthedictionary’scontentsbetweenthesetwo(items()andvalues()),Pythonguaranteesthattheorderofthetworesultswillbethesame.

Table7.2:PythonDictionaryMethods

SolvedPrograms1. Writeapythonprogramtoinput‘n’namesandphonenumberstostoreitina

dictionaryandtoinputanynameandtoprintthephonenumberofthatparticularname.

phonebook={}

n=int(raw_input(“Enterthenumberofentries”))

foriinrange(n):

name=raw_input(“Name:“)

phone=raw_input(“Number:“)

phonebook[name]=phone

printphonebook

name=raw_input(“Enternametosearch:“)

ifnameinphonebook:

print(“Thenumberis”,phonebook[name])

2.Writeaprogramtoinput‘n’employeenumberandnameandtodisplayall

employee’sinformationinascendingorderbasedupontheirnumber.

empinfo=dict()

n=int(raw_input(“Entertotalnumberofemployees”))

whilei<=n:

a=raw_input(“enternumber”)

b=raw_input(“entername”)

empinfo[a]=b

l=empinfo.keys()

l.sort()

print“EmployeeInformation”

print“EmployeeNumber”,‘\t’,“EmployeeName”

foriinl:

printi,‘\t’,empinfo[i]

3.Writeaprogramtoformafrequencytableofwordsinagiventext.

freq={}#frequencyofwordsintext

line=raw_input(“Entertext:“)

line=line.lower()

forchin‘!%.?,{”}’:

line=line.replace(ch,‘‘)

forwordinline.split():

freq[word]=freq.get(word,0)+1

words=freq.keys()

words.sort()

forwinwords:

print“%s:%d”%(w,freq[w])

PracticeProblems

1.Writethecodetoinputany5yearsandthepopulationofanycityandprintitonthescreen.

2.Writeaprogramtosimulateaphonebook.

3.Writeacodetocreatecustomer’slistwiththeirnumber&nameanddeleteanyparticularcustomerusinghis/hernumber.

4.Writetheoutputforthefollowingcodes.

A={10:1000,20:2000,30:3000,40:4000,50:5000}

printA.items()

printA.keys()

printA.values()

5.WriteaPythonprogramtoinput‘n’namesandphonenumberstostoreitinadictionaryandprintthephonenumberofaparticularname.

6.Writeaprogramtocreateaphonebookanddeleteparticularphonenumberusingname.

7.Finderrorsfromthefollowingcodes:

c=dict()

n=input(Entertotalnumber)

whilei<=n

a=raw_input(“enterplace”)

b=raw_input(“enternumber”)

c[a]=b

print“place”,“\t”,“number”

foriinc:

printi,“\t”,c[a[i]]

Chapter8:Tuples

Atupleisasequenceofvalues,whichcanbeofanytypeandtheyareindexedby

integer.Tuplesarejustlikelist,butwecan’tchangevaluesoftuplesinplace.Thustuplesareimmutable.Theindexvalueoftuplestartsfrom0.

TupleCreation

Atupleconsistsofanumberofvaluesseparatedbycommas.

Ex8.1:Tuplecreation

tup1=(‘desktop’,‘laptop’,1997,2000)

tup2=(1,2,3,4,5)

tup3=“a”,“b”,“c”,“d”

printtup1

printtup2

printtup3

Butintheresult,sametupleisprintedusingparentheses.Tocreateatuplewithsingleelement,wehavetousefinalcomma.Avaluewithintheparenthesisisnottuple.

Theemptytupleiswrittenastwoparenthesescontainingnothing:

tup1=()

Towriteatuplecontainingasinglevaluewehavetoincludeacomma,eventhoughthereisonlyonevalue:

tup1=(50,);

Example8.2:Createtupleswithsinglecharacter.

T=(‘P’,‘Y’,‘T’,‘H’,‘O’,‘N’)

printT

Anotherwayofcreatingtupleisbuilt-infunctiontuple().

T=tuple()

printT

Fig8.1:creatingtupleusingbuilt-infunction

Tupleinsertion

Wecanaddnewelementtotupleusing+operator.

t=(1,2,3,4)

t+(5,)#thiswillnotcreatemodificationoft.

printt

t=t+(5,)#thiswilldomodificationoft.

printt

Fig8.2:Tupleinsertion

Example8.3:Writeaprogramtoinput‘n’numbersandstoreitintuple.

t=tuple()

n=input(“Entercountofnumbers”)

print”enterallnumbersoneafterother”

foriinrange(n):

a=input(“enternumber”)

t=t+(a,)

print“outputis”

foriinrange(n):

printt[i]

Wecanalsoaddnewelementtotuplebyusinglist.Forthatwehavetoconvertthetupleintoalistfirstandthenuseappend()functiontoaddnewelementstothelist.Aftercompletingtheaddition,convertthelistintotuple.

Example8.4:Addnewelementstotupleusingalist.

T=tuple()#createemptytuple

l=list(T)#converttupleintolist

l.append(11)#Addnewelementstolist

l.append(22)

T=tuple(l)#convertlistintotuple

printT

Tupleinitialization

Wecaninitializeatupleasfollows

T=(0,)*5

printT

Fig8.3:Tupleinitialization

TupleAssignment

Ifwewanttointerchange(swap)anytwovariablevalues,wehavetousetemporaryvariable.Butinpython,tupleassignmentismoreelegant.

T1=(10,20,30)

T2=(100,200,300,400)

T1,T2=T2,T1#swapT1andT2

printT1

printT2

Fig8.4:Tupleassignment

Theleftsideisatupleofvariables,whiletherightsideisatupleofexpressions.Eachvalueisassignedtoitsrespectivevariable.Alltheexpressionsontherightsideareevaluatedbeforeanyoftheassignments.Thenumberofvariablesontheleftandthenumberofvaluesontherighthavetobethesame.

T1=(10,20,30)

T2=(100,200,300)

T3=(1000,2000,3000)

T1,T2=T2,T1,T3

Fig8.5:Tupleassignmenterror

Here,twotuplesareintheleftsideandthreetuplesareinrightside.Thatiswhy,wegeterrors.Thus,itisrequiredtohavesamenumberoftuplesinbothsidestogetthecorrectresult.

TupleSlices

SliceoperatorworksonTuplealso.Thisisusedtodisplaymorethanoneselectedvalueontheoutputscreen.Slicesaretreatedasboundariesandtheresultwillcontainalltheelementsbetweenboundaries.

Syntax:Seq=T[start:stop:step]

Wherestart,stop&stepallthreeareoptional.Ifweomitfirstindex,slicestartsfrom‘0’.Onomittingstop,slicewilltakeittoend.Defaultvalueofstepis1.

T=(1,2,3,4,5)

printT

T1=T[2:4]

print“T[2:4]=”,T1

print“T[:]=”,T[:]#Willproduceacopyofthewholetuple.

print“T[::2]=”,T[::2]#WillproduceaTuplewitheveryalternateelement.

print“T[:3]=”,T[:3]#Willproduce0to2(3-1)

print“T[2:]=”,T[2:]#Willproducefrom2toend.

Fig8.6:Tupleslice

UpdatingTuples

Tuplesareimmutablewhichmeansyoucannotupdatethemorchangevaluesoftupleelements.

tup1[0]=100;#Invalid

Butweabletotakeportionsofanexistingtuplestocreateanewtuplesasfollows.

tup1=(12,34.56);

tup2=(‘abc’,‘xyz’);

tup3=tup1+tup2;

printtup3;

Fig8.7:Tupleupdation

DeleteTupleElements

Itisnotpossibletoremoveindividualtupleelements.Thereis,ofcourse,nothingwrong with putting together another tuple with the undesired elements discarded. Toexplicitlyremoveanentiretuple,justusethedelstatement.

T=(1,2,3,4,5)

printT

Fig8.8:Tupledeletion

BasicTuplesOperations

Tuples respond to the + and * operators much like strings; they meanconcatenationandrepetitionheretoo,exceptthattheresultisanewtuple,notastring.

Description PythonExpression

Results

Length len((1,2,3)) 3

Concatenation (1,2,3)+(4,5,6)

(1,2,3,4,5,6)

Repetition [‘Hello!’]*4 (”Hello!’,”Hello!’,”Hello!’,”Hello!’)

Membership 1in(1,2,3) True

Iteration forxin(1,2,3):

printx,

Table8.1:Tupleoperations

Built-inTupleFunctions

Pythonincludesthefollowingtuplefunctions

1 cmp(tuple1,tuple2)

Thisisusedtocheckwhetherthegiventuplesaresameornot.Ifbotharesame,itwillreturn‘zero’,otherwisereturn1or-1.Ifthefirsttupleisbig,thenitwillreturn1,otherwisereturn-1.

tuple1=(11,22,33,44,55)

tuple2=(111,222,333,444,555)

printcmp(tuple1,tuple2)

2 len(tuple)

Itreturnsthenumberofitemsinatuple.

printlen(tuple1)

3 max(tuple)

Itreturnsitslargestiteminthetuple.

printmax(tuple1)

4 min(tuple)

Itreturnsitssmallestiteminthetuple.

printmin(tuple1)

5 tuple(seq)

Convertsalistintotuple.

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

printtuple(seq)

>>(1,2,3,4,5)

Table8.2:Tuplebuilt-infunctions

SolvedPrograms1. Writeaprogramtoinput5subjectnamesandputitintupleanddisplaythat

tupleinformationontheoutputscreen.

t=tuple()

print”Enter5courses”;

foriinrange(5):

a=raw_input(“Entercoursename”)

t=t+(a,)

print“outputis”

printt

2. Writeaprogramtoinputanytwotuplesandinterchangethetuplevalues.

t1=tuple()

n=input(“Totalnumberofvaluesinfirsttuple”)

foriinrange(n):

a=input(“enterelements”)

t1=t1+(a,)

t2=tuple()

m=input(“Totalnumberofvaluesinfirsttuple”)

foriinrange(m):

t2=t2+(a,)

print“FirstTuple”

printt1

print“SecondTuple”

printt2

t1,t2=t2,t1

print“AFTERSWAPPING”

print“FirstTuple”

printt1

print“SecondTuple”

printt2

PracticeProblems1. Writeaprogramtoinput‘n’employees’salaryandfindminimum&maximumsalary

among‘n’employees.

2.Writetheoutputfromthefollowingcodes;

(i)t=(10,20,30,40,50)

printlen(t)

(ii)t=(‘a’,‘b’,‘c’,‘A’,‘B’)

max(t)

min(t)

(iii)T1=(10,20,30,40,50)

T2=(10,20,30,40,50)

T3=(100,200,300)

cmp(T1,T2)

cmp(T2,T3)

cmp(T3,T1)

(iv)t=tuple()

Len(t)

(iv)T1=(10,20,30,40,50)

T2=(100,200,300)

T3=T1+T2

printT3

3.Writeaprogramtoinputtwosetvaluesandstoreitintuplesandalsodothecomparison.

4.Findtheerrorsfromthefollowingcode:

t=tuple{}

n=input(Totalnumberofvaluesintuple)

foriinrange(n)

t=t+(a)

print“maximumvalue=”,max(t)

print“minimumvalue=”,min(t)

5.Writeaprogramtoinput‘n’numbersandseparatethetupleinthefollowingmanner.

Example

T=(10,20,30,40,50,60)

T1=(10,30,50)

T2=(20,40,60)

6.Findtheoutputfromthefollowingcode:

T=(10,30,2,50,5,6,100,65)

printmax(T)

printmin(T)

7.Findtheoutputfromthefollowingcode:

t=tuple()

t=t+(PYTHON,)

printt

printlen(t)

t1=(10,20,30)

printlen(t1)

Chapter9:Classes,ObjectsandInheritance

Aclassisadefinitionofanobject.Aclassisauserdefineddatatypejustlikeint,andanobjectofthisclassisjustavariable.Whenwedefineaclass,wedefineablueprintfor a data type. A class is used to specify the form of an object and it combines datarepresentationandmethodsformanipulatingthatdataintooneneatpackage.Thedataandfunctionswithinaclassarecalledmembersoftheclass.

Namespaces

Anamespaceisamappingfromnamestoobjects.Itisaplacewhereavariable’snameisstored.Pythonhasthefollowingnamespacesandsearchesinthefollowingorder.

Localcanbeinsideafunctionorclassmethod,forexampleinsidedef

Enclosedcanbeitsenclosingfunction,e.g.,ifafunctioniswrappedinsideanotherfunction.Thevariableissearchedinallenclosingfunctionsfrominnertoouter.

Globalreferstotheuppermostlevel.Thevariableissearchedinglobalmodulesorfornamesdeclaredglobalinadef.

Built-inarespecialnamesthatPythonreservesforitself.

Fig9.1:PythonNamespaces

Definingclasses

A class definition starts with the keyword class followed by the class name and acolon;ForexamplewedefinedtheStudentdatatypeusingthekeywordclassasfollows:

classStudent:

count=0

#constructortocreateanobject

def__init__(self,rollno,marks):

self.rollno=rollno

self.marks=marks

defread(self):#Thisfunctiongetsthedetailsofastudentfromtheuser

Student.count+=1

defdisplay(self):#Thisfunctionprintseachstudent’sdetails

In the above class definition rollno,marks,read() and display() are attributes of theclassstudent.

The init function is the first method and is a special method called constructor orinitializationmethod.Itisusedtoinitializethedatamembersofaclass.Itisthefirstpieceofcodeexecutedinanewlycreatedinstanceoftheclass.

Itcantakeanynumberofargumentsandalsodefaultarguments.

Objects

Anobject iscreated fromaclass.Wedeclareobjectsofaclasswithexactly thesame sort of declaration thatwe declare variables of basic types. Following statementsdeclaretwoobjectsofclassStudent:

S1=Student();//Declares1oftypeStudent

S2=Student();//Declares2oftypeStudent

Bothoftheobjectss1ands2willhavetheirowncopyofdatamembers.

Objectsofaclasshaveasamestructureandbehavior.Theywillonlydifferregardingtheirstate(values).

Thefirstargumentofeveryclassmethodisalwaysareferencetothecurrentinstanceof the class named “self”. This is the only difference between a class method and anordinaryfunction.“self”isnotakeywordandisjustusedforreadabilityanduniformity.Itisaninstanceidentificator.

Hereisanexampleusingself

classStock:

discount=5

def__init__(self,icode,price,qty):

self.icode=icode

self.price=price

self.qty=qty

#Displaysitemdetails

defdisplay(self):

print“ItemCode:”,self.icode

print“Price:Rs”,self.price

print“Quantity:“,self.qty

Intheaboveexample,discountisaclassvariablewhosevaluewouldbesharedamongallinstancesofthisclass.Theycanbeaccessedas

Stock.discount

Instance attributes belong to each instance/object of a class. i.e. S1.icode ands2.icodewillhave2differentvalues

ACCESSINGATTRIBUTES

Attributescanbeaccessedbyusingthedotoperator.

Thegetattr(obj,name[,default]):toaccesstheattributeofobject.

Thehasattr(obj,name):tocheckifanattributeexistsornot.

Thesetattr(obj,name,value):tosetanattribute.Ifattributedoesnotexist,thenitwouldbecreated.

Thedelattr(obj,name):todeleteanattribute.

getattr(obj1,‘price’)#Returnsvalueof‘price’attribute

hasattr(obj1,‘price’)#Returnstrueif‘price’attributeexists

setattr(obj1,‘price’,30.56)#Setattribute‘price’at30.56

delattr(obj1,‘price’)#Deleteattribute‘price’

BUILT-INCLASSATTRIBUTES

EveryPythonclasskeepsfollowingbuilt-inattributesandtheycanbeaccessedusingdotoperatorlikeanyotherattribute:

__dict__:Dictionarycontainingtheclass’snamespace.

__doc__:ClassdocumentationstringorNoneifundefined.

__name__:Classname.

__module__:Modulenameinwhichtheclassisdefined.Thisattributeis“__main__”ininteractivemode.

__bases__:Apossiblyemptytuplecontainingthebaseclasses,intheorderoftheiroccurrenceinthebaseclasslist.

__del()__ordestructor

Thisfunctioniscalledwhentheinstanceisabouttobedestroyed.Itcallsthemethod-object.__del__(self)

Considerthefollowingcommandisgiven

>>>delS1

Theabovecommanddoesn’tdirectlycallS1.__del__().FirstthereferencecountforS1isdecrementedbyoneand__del()__iscalledonlywhenS1’sreferencecountreacheszeroi.e.whenallthevariablesreferencedbyS1havebeendeleted.

__str()__

Itisaspecialfunctionwhichreturnsthestringrepresentationoftheobjects.Itcallsthemethod

object.__str__(self).Iftheclassdefinesa__str__method,Pythonwillcallitwhenyoucallthestr()oruseprintstatement.Thestr()built-infunction,whenusedalongwiththeprintstatementcomputesthe“informal”stringrepresentationofanobject.

classStudent:

……….

………..

def__str__(self):

return“ThisclassisaboutaStudent?”

>>>S=Student()

>>>printS

Hello,Howareyou?

Whenyougivethecommandto“printS”,Pythoncallsstr(S)togetthestringrepresentationofS.IftheclassofShasa__str__method,str(S)becomesacalltoS.__str__().Thisreturnsthestringtoprint.

Privatevariables

“Private” instance variables are not supported in Python. It can be achievedthroughnamemangling.Aname isprefixedwith two leadingunderscoresandnomorethanonetrailingunderscoretomakeitasaprivatemember.

ClassStudent:

Rollno=121

Grade=‘A’

__age=15#privatemember

Datahiding is ameans to enforce encapsulation.Toaccess thishiddenvariable,weneedtofollowthesyntax

ClassName.__var-name

Ex:-Student.__age=20

DYMANICALLYADDINGMETHODS

DynamicClassMethodAddition

Occasionallyyoumayneeddynamicallyaddafunctionasamethodtoaclass.Thisiseasilyaccomplishedbyassigningthefunctionasanattributeoftheclass.

deffn(self):

returnid(self),self,type(self)

classA_Class(object):

defmethod_a(self):

returnid(self),self,type(self)

A=A_Class()

#Modifytheclassandaddfnasamethod

setattr(A_Class,‘method_b’,fn)

A.method_a()

#Callthedynamicallyaddedmethod

A.method_b()

DynamicInstanceMethodAddition

Whenweaddthemethodtoaclassallinstancescanaccessit.Ifweonlywantaparticularinstancetohaveamethoddothis:

fromtypesimportMethodType

A=A_Class()

setattr(A,fn.__name__,MethodType(fn,A,type(A)))

#CallsthefnmethodattachedtotheinstanceA

A.fn()

#Throwsanexception

A.fn()

StaticMethods

Astaticmethodiscallablewithoutanobject.

classStudent:

@staticmethod

defgetStudentcount():

returncount

printStudent.getStudentCount()

In the above example, the function getStudentcount () dosen’t use self. They areprecededwith a decorator@staticmethod and it is being calledwithout the instance. Iteasesthereadabilityofthecode.Staticmethodsareaccessiblefromeitheranobjectoraclass.

DestroyingObjects(GarbageCollection)

Pythonautomaticallyallocatesandde-allocatesmemory.TheuserdoesnothavetopreallocateordeallocatememorybyhandasonehastowhenusingdynamicmemoryallocationinlanguagessuchasCorC++.Pythonusestwostrategiesformemoryallocation-referencecountingandautomaticgarbagecollection.

i)ReferenceCounting

Referencecountingcountsthenumberoftimesanobjectisreferencedbyotherobjectsinthesystem.Anobject’sreferencecountchangesasthenumberofaliasesthatpointtoitchange.Anobject’sreferencecountincreaseswhenitisassignedanewnameorplacedinacontainer(list,tupleordictionary).Theobject’sreferencecountdecreaseswhenitisdeletedwithdel,itsreferenceisreassigned,oritsreferencegoesoutofscope.Whenanobject’sreferencecountreacheszero,Pythoncollectsitautomatically.

Considerthecodegivenbelow:

A=5#anobjectAiscreatedwhichisboundto5.

B=A#increaseinreferencecountof5

C[0]={B}#increaseinreferencecountof5

delA#decreaseinreferencecountof5

B=10#decreaseinreferencecountof5

Aclasscanimplementthespecialmethod__del__(),calledadestructor,thatisinvokedwhentheinstanceisabouttobedestroyed.Referencecountingisextremelyefficientbutitcannothandlereferencecycles.Areferencecycleiswhenthereisnowaytoreachanobjectbutitsreferencecountisstillgreaterthanzero.Theeasiestwaytocreateareferencecycleistocreateanobjectwhichreferstoitselfasintheexamplebelow:

defreference_cycle():

x.append(x)

reference_cycle()

Intheaboveexamplesincereference_cycle()createsanobjectxwhichreferstoitself(statementx.append(x)),xwillnotautomaticallybefreedwhenthefunctionreturns.ThiswillcausethememorythatxisusingtobeheldontountilthePythongarbagecollectorisinvoked.

ii)AutomaticGarbageCollection

Inthiscasegarbagecollectionisascheduledactivity.Pythonschedulesgarbagecollectionbaseduponathresholdofobjectallocationsandobjectde-allocations.Pythondeletestheobjectswhicharenotrequired,mayitbebuilt-intypesorclassinstances,throughtheprocessnamedgarbagecollection.

Whenthenumberofallocationsminusthenumberofde-allocationsaregreaterthanthethresholdnumber,thegarbagecollectorisrunandtheunusedblockofmemoryisreclaimed.Onecaninspectthethresholdfornewobjectsbyloadingthegcmoduleandaskingforgarbagecollectionthresholds.

AutomaticgarbagecollectionwillnotrunifyourPythondeviceisrunningoutofmemory.Insuchcase,yourapplicationwillthrowexceptions,whichmustbehandledotherwiseyourapplicationwillcrash.Itoccursmoreforthenumberoffreeobjectsnotthesizeofobjects.

Inheritance

Inheritanceallowsustodefineaclassintermsofanotherclass,whichmakesiteasiertocreateandmaintainanapplication.Thisalsoprovidesanopportunitytoreusethecodefunctionalityandfastimplementationtime.

Whencreatingaclass,insteadofwritingcompletelynewdatamembersandmemberfunctions,theprogrammercandesignatethatthenewclassshouldinheritthemembersofanexistingclass.Thisexistingclassiscalledthebaseclass,andthenewclassisreferredto as the derived class. The idea of inheritance implements the IS-A relationship. Forexample,mammalIS-Aanimal,dogIS-AmammalhencedogIS-Aanimalaswellandsoon.

Formsofinheritance

Singleinheritance:Whenasubclassinheritsfromonlyonebaseclass,andthereareonly2classesinthisrelationship,thenitisknownassingleinheritance.

Fig10.1:SingleInheritance

Multilevelinheritance:Whenasubclassinheritsfromaclassthatitselfinheritsfromanotherclass,itisknownasmultilevelinheritance.

Fig10.2:MultilevelInheritance

Multipleinheritance:Whenasubclassinheritsfrommultiplebaseclassesitisknownasmultipleinheritance.

Fig10.3:MultipleInheritance

Hierarchicalinheritance:Whenmanysubclassesinheritfromasinglebaseclassitisknownashierarchicalinheritance.

Fig10.4:HierarchicalInheritance

Hybridinheritance:Hybridinheritancecombines2ormoreformsofinheritance.

Fig10.5:HybridInheritance

BaseOverloadingMethods

S.No Method Description Usage

1 __init__(self[,args…])

Constructor obj=className(args)

2 __del__(self)

Destructor,deletesanobject

delobj

3 __repr__(self)

Evaluateablestringrepresentation

repr(obj)

4 __str__(self) Printablestringrepresentation

str(obj)

5 __cmp__(self,x)

Comparisonofobjects

cmp(obj,x)

SingleInheritance

Person is the base class from which a student derives. It has 2 private datamembers:person’snameasstringandageasaninteger.Ithas2methodsread()anddisp()togetanddisplaypersondetails.

Studentclass isdefinedwithrollnumberasan integerandaverageasfloat. Ithas3memberfunctions

readStudent()–internallycallsread()ofPersonclassandgetstherollnoandaverageofstudent.

disprollno()–displaysrollnumberofstudent

getaverage()–returnstheaverageofthestudent

Fig10.6:SingleInheritanceexample

classPerson(object):

def__init__(self):

self.name=””

self.age=0

defget(self):

self.name=raw_input(“EntertheName:”)

self.age=int(raw_input(“Age?”))

defdisp(self):

print“Name:”,self.name,“\tAge:”,self.age

classStudent(Person):

def__init__(self):

super(Student,self).__init__()

self.rollno=0

self.avg=0.0

defreadStudent(self):

#Callgetmethodofparentclass

super(Student,self).get()

self.rollno=int(raw_input(“EntertheRollNumber:”))

self.avg=float(raw_input(“Average?”))

defdisprollno(self):

print“RollNo.:”,self.rollno

defgetaverage(self):

returnself.avg

TheclassStudentextendstheclassPerson.Theclassstudentadds2newinstancevariablesrollnoandavg.Inordertoaddnewinstancevariables,the__init__()methoddefinedinclassPersonneedstobeextended.ThisfunctionofsubclassStudentinitializesthenameandageattributesofthesuperclassPersonandalsocreatesnewattributesrollnoandavg.

Let’sexecutethefollowingstatements

p=Person()

p.get()

s=Student()

s.readStudent()

Itwouldproducethefollowingoutput.

Intheabovecodesegment,theobject(p)ofclasspersontakesvaluesforinstancevariablesnameandage.Theobject(s)ofclassstudentcaninvokereadstudent()function.

Theinitfunctioncanbeextendedinin2ways.

(i)Byusingsuper()function:Theinit()methodisdefinedinthebaseclassandisextendedinthesubclass.Super()functionisusedtocallbaseclassmethodswhichhasbeenextendedinderivedclass.

Ex:-super(Student,self).__init__(self,name,age)

(ii)Byusingsuperclass’sname:Thenameofthebaseclasscanalsobeusedtoaccessthemethodofthebaseclasswhichhasbeenextended.

Ex:-Person.__init__(self,name,age)

MULTILEVELINHERITANCE

Theabovesingleinheritancecanbeextendedtoamultilevelinheritance.GradStudentisanotherclasswhichderivesfromtheclassStudent.SoGradStudentindirectlyinheritsfromPersonclass.Ithas2memberssubjectofgraduationandworkstatusasasingle

charactery-yesandn-no.Ithas3memberfunctions

readGrad()–callsreadStudent()togetstudentdetails(whichinturncallsread()ofPersonclass)andalsogetstheGraduate’sdetails

workstatus()–returnstheworkstatusyorn

displaySubject()–printsthesubject

classGradStudent(Student):

def__init__(self):

super(GradStudent,self).__init__()

self.subject=””

self.working=”

defreadGrad(self):

#CallreadStudentmethodofparentclass

super(GradStudent,self).readStudent()

self.subject=raw_input(“Entersubjectofgraduation”)

self.working=raw_input(“Working?y/n”)

defworkstatus(self):

returnself.working

defdisplaysubject(self):

print“Subject:”,self.subject

Thesamewayinit()andtheothermethodscanbecalledusingsuperortheclassname.

MultipleInheritance

Python supportsmultiple inheritance. The general syntax ofmultiple inheritance is

givenbelow.

classDerived(Base1,Base2,Base3):

……

Ifanattribute/methodisnotfoundinDerived,itissearchedinBase1andonlyifitisnotthereitissearchedinthesubsequentbaseclasses.

MethodOverriding

Overridingenablestheprogrammertoprovidespecificimplementationtoamethodinthederivedclass.So,themethodinvokeddependsontheobjectusedtoinvokeit.Ifbaseclassobjectisusedthenbaseclassversionofthemethodiscalledelsethederivedclassmethodiscalled.

Theissubclass(sub,sup)booleanfunctionreturnstrueifthegivensubclasssubisindeedasubclassofthesuperclasssup.

Theisinstance(obj,Class)booleanfunctionreturnstrueifobjisaninstanceofclassClassorisaninstanceofasubclassofClass

Abstractmethods

Anunimplementedmethodiscalledanabstractmethod.Thesemethodsaredeclaredinaparentclass,butnotimplementedinit.Theimplementationisdoneinthederivedclass.

classShape(object):

deffindArea(self):

raiseNotImplementedError

S=Shape()

S.findArea()

Wegetthefollowingerror

Now,theaboveclasscanbeextendedasbelow

classShape(object):

deffindArea(self):

raiseNotImplementedError

classSquare(Shape):

def__init__(self,side):

self.side=side

deffindArea(self):

returnself.side*self.side

S=Square(10)

printS.findArea()

Theoutputoftheprogramisshownbelow

Whenanabstractmethodisdeclaredinabaseclass,thederivedclasshastoeither

definethemethodorraise“NotImplementedError”.

Theerrorwillberaisedonlyifwetrytousethatmethod.Thismightbeusefulwhenwedonotwanttoimplementcertainmethodsinthederivedclass.Butifweneedtoensurethatthederivedclassoverridesthismethodwecouldusethe“abc”moduleofPython.

importabc

classShape(object):

__metaclass__=abc.ABCMeta

@abc.abstractmethod

deffindArea(self):

“““Methodthatshoulddosomething.”””

classSquare(Shape):

def__init__(self,side):

self.side=side

deffindArea(self):

returnself.side*self.side

S1=Shape()

S2=Square(10)

HeretheobjectS2doesn’tcreateaproblembecausethefindArea()methodisimplemented.

SolvedQuestions

1.Whatdoyouunderstandaboutamember function?Howdoes itdiffer fromanordinaryfunction?

Ans:Amemberfunctionispartofaclassandcanbecalledonlywithanobject.Anordinaryfunctioncan’tbecalledbyanobject.Amemberfunctiontakes“self”asthefirstargumentwhileanordinaryfunctiondoesn’t.

2.Predicttheoutputofthefollowingcodesnippet

ptr=40

defresult():

printptr

ptr=90

deffunc(var):

ifvar<=60:

ptr=30

printptr

result()

func(60)

func(70)

UnboundLocalError:localvariable‘ptr’referencedbeforeassignment

3.Predicttheoutputofthefollowingcodesnippet

ptr=50

defresult():

globalptr

ptr=ptr+1

Percentage ofmarks

80to100 A

printptr

result()

printptr

4.Namethemethodsthatcanbeusedto

a.accessattributeofanobject

b.deleteanattributeofanobject

a.getattr(obj,name[,default])

b.delattr(obj,name)

5.Givethestatementto

a.CheckwhethertheattributestrexistsintheclassTestwhoseobjectisT1

b.Assignavalue“Hello”totheattributestrofclassTestandobjectT1.

a.hasattr(T1,str)

b.setattr(T1,str,“Hello”)

6.WriteaPythonprogramusingclassesandobjectstosimulateresultpreparationsystemfor20students.Thedataavailableforeachstudentincludes:Name,Rollno,andMarksin3subjects.Thepercentagemarksandgradearetobecalculatedfromthefollowinginformation

Gradeformula

Alsodemonstrateconstructoroverloading.

60to80 B

45to60 C

Lessthan45 D

classStudent:

def__init__(self,s=None):

#non-copyconstructor

ifs==None:

self.rollno=0

self.name=”

self.marks=[0,0,0]

self.avg=0.0

self.grade=”

#copyconstructor

self.rollno=s.rollno

self.name=s.name

self.marks=s.marks

self.avg=s.avg

self.grade=s.grade

defread(self):

#Thisfunctiongetsthedetailsofastudentfromtheuser

self.rollno=raw_input(“Enterrollnumber:-”)

self.name=raw_input(“Entername:-”)

foriinrange(0,3):

self.marks[i]=int(raw_input(“Enterthemarks?”))

s=s+self.marks[i]

self.avg=s/3

if(self.avg>60):

self.grade=‘A’

elifself.avg>40:

self.grade=‘B’

self.grade=‘C’

defdisplay(self):

#Thisfunctionprintseachstudent’sdetails

printself.rollno,“\t”,self.name,“\t\t”,self.grade

s=Student()

studlist=[]

num=int(raw_input(“Enterno.ofstudents:-”))

foriinrange(0,num):

s.read()

studlist.append(Student(s))

print”STUDENTREPORT\n”

print“*******************************************\n”

print“RollNo\tName\t\tGrade”

print“*******************************************\n”

foriinrange(0,num):

studlist[i].display()

#Initializeavgasthefirststudent’savg

maxavg=studlist[0].avg

totavg=0

foriinrange(1,num):

totavg=totavg+studlist[i].avg

ifstudlist[i].avg>maxavg:

maxavg=studlist[i].avg

topper=studlist[i].name

totavg=totavg/num

print“Classtopperis”,studlist[i].name,“withaverage”,studlist[i].avg

print“Classaverageis”,totavg

7.DefineaclassTravelinPythonwiththefollowingdescriptions:

PrivateMembers:

PlanCodeoftypelong

Placeoftypecharacterarray(string)

No_of_travellersoftypeinteger

No_of_busesoftypeinteger

PublicMembers:

AconstructortoassigninitialvaluesofPlanCodeas1001,Placeas“Agra”,

No_of_travellersas5,No_of_busesas1

AfunctionNewPlan()whichallowsusertoenterPlanCode,Placeand

No_of_travellers.Also,assignthevalueofNo_of_busesasperthe

followingconditions:

No_of_travellersNo_of_buses

Lessthan201

Equaltoormorethan20andlessthan402

Equalto40ormorethan403

AfunctionShowPlan()todisplaythecontentofallthedatamembersonscreen.

classTravel:

def__init__(self):

self.PlanCode=1001

self.Place=“Agra”

self.No_of_travellers=5;

self.No_of_buses=1;

defNewPlan(self):

self.PlanCode=input(“Enterplancode”)

self.Place=raw_input(“EnterPlace”)

self.No_of_travellers=input(“EnterNo.oftravellers”)

if(self.No_of_travellers<20):

self.No_of_buses=1;

elif(self.No_of_travellers<40):

self.No_of_buses=2;

self.No_of_buses=3;

defShowPlan(self):

printself.PlanCode,self.Place,self.No_of_travellers,self.No_of_buses

t=Travel()

t.NewPlan()

t.ShowPlan()

8.Definetheterminheritance.

Ans.Inheritanceisamechanisminwhichanewclassisderivedfromanalreadydefinedclass.Thederivedclassisknownasasubclassorachildclass.Thepre-existingclassisknownasbaseclassoraparentclassorasuperclass.Themechanismofinheritancegivesrisetohierarchyinclasses.Themajorpurposeofinheritingabaseclassintooneormorederivedclassiscodereuse.Thesubclassinheritsallthemethodsandpropertiesofthesuperclass.

9.Giveoneexampleforabstractmethod?

Ans.Anabstractmethodisamethoddeclaredinaparentclass,butnotimplementedinit.Theimplementationofsuchamethodcanbegiveninthederivedclass.

classcircle(object):

defget_radius(self):

10.Whatissingleinheritance?

Ans.:Insingleinheritanceasubclassisderivedfromasinglebaseclass.

11.Whatismultipleinheritance?Explainwithanexample.

Ans.:Inthistypeofinheritance,thederivedclassinheritsfromoneormorebaseclasses.Inthefigurebelow,XandYarethebaseclasseswhileZisthederivedclass.

12.Giveoneexampleofmultilevelinheritance.

Ans.:Inmultilevelinheritance,thederivedclassbecomesthebaseofanotherclass.

Ex:CountryisthebaseclassofStateandCityisthederivedclassofState.

13.DefineaclassemployeeinPythonwiththegivenspecifications:

Instancevariables:

Employeenumber,name

Methods:

Getdata()-Toinputemployeenumberandname

Printdata()-Todisplayemployeenumberandname

Defineanotherclasspayroll,whichisderivedfromemployee

Instancevariable

SalaryomputerScience

Methods:

Inputdata()-TocallGetdata()andinputsalary.

Outdata()-Tocallprintdata()andtodisplaysalary.

Defineanotherclassleave,whichisderivedfrompayroll.

Instancevariable

Noofdays

Methods:

acceptdata()-TocallInputdata()andinputnoofdays.

showdata()-TocallOutdata()andtodisplaynoofdays.

Implementtheaboveprograminpython.

classEmployee(object):

def__init__(self):

self.eno=0

self.name=”

defGetdata(self):

self.eno=input(“EntertheEmployeeno:”)

self.name=raw_input(“EntertheEmployeeName:”)

defPrintdata(self):

print“EmployeeNumber”,self.eno

print“EmployeeName”,self.name

classpayroll(Employee):

def__init__(self):

super(payroll,self).__init__()

self.salary=0

defInputdata(self):

self.Getdata()

self.salary=float(raw_input(“Enterthesalary:”))

defOutdata(self):

self.Printdata()

print“Salaryis”,self.salary

classleave(payroll):

def__init__(self):

super(leave,self).__init__()

self.Noofdays=0

defacceptdata(self):

self.Inputdata()

self.Noofdays=input(“Enterleavedays”)

defshowdata(self):

self.Outdata()

print“No.ofleavedays”,self.Noofdays

leaveobj=leave()

leaveobj.acceptdata()

leaveobj.showdata()

PracticeQuestions1. HowareobjectsdestroyedinPython?2. CanweaddmethodsdynamicallyinPython?Explainwithanexample.3. ExplaintheimportanceofselfinPythonclasses.4. DefineaclassITEMINFOinPythonwiththefollowingdescription:

ICode(ItemCode),Item(ItemName),Price(Priceofeachitem),Qty(quantityinstock),Discount(Discountpercentageontheitem),Netprice(FinalPrice)

Methods

AmemberfunctionFindDisc()tocalculatediscountasperthefollowingrule:

IfQty<=10Discountis0

IfQty(11to20)Discountis15

IfQty>=20Discountis20

Aconstructor(__init__method)toassignthevaluewith0forICode,Price,Qty,NetpriceandDiscountandnullforItemrespectively

AfunctionBuy()toallowusertoentervaluesforICode,Item,Price,QtyandcallfunctionFindDisc()tocalculatethediscountandNetprice(Price*Qty-Discount).

AFunctionShowAll()toallowusertoviewthecontentofallthedatamembers

5.DefineaclassBankinPythonwiththefollowingdescription:Datamembers:Nameofthedepositor:String,Accountnumber:long,Typeofaccount(Savingsorcurrent):character,Balanceamount:decimal.

MemberFunctions:

Initialize()–Itreadsthecustomername,accountnumber;accounttypeandcurrentbalanceandinitializesthecustomerobject.

Deposit()–Increasesbalanceamount.

Withdraw()–Checksforminimumbalanceincurrentaccountanddecreasesthebalanceaccordingly.

Display()–Displaysthecustomerdetails.

6.Whatistheuseoftheinit()functionininheritance?Explainthe2waysinwhichitcouldbeinvoked.

7.Whatisthesignificanceofsuper()function?

8.Whatareabstractmethods?HowdoweimplementabstractmethodsinPython.Giveanexample.

9.Findtheoutputofthefollowingcodeandwritethetypeofinheritance:

classperson(object):

def__init__(self,name):

self.name=name

defdisplay(self):

print“Name:”,self.name

classstudent(person):

def__init__(self,name,rollno,marks):

super(student,self).__init__(name)

self.rollno=rollno

self.marks=marks

defdisp(self):

self.display()

print”RollNo:”,self.rollno

print”Marks:”,self.marks

s=student(‘Kali’,11009,78)

s.disp()

10.DefineaclassfurnitureinPythonwiththegivenspecifications:

Instancevariables:Type,Model,

Methods:getType()-ToreturninstancevariableType

getModel()-ToreturninstancevariableModel

show()ToprintinstancevariableTypeandModel

Defineaclasssofa:

No_of_seats,Cost

Methods

getSeats()ToreturninstancevariableNo_of_seats

getCost()ToreturninstancevariableCost

show()ToprintinstancevariableNo_of_seatsandCost

Thisclassinheritsclassfurniture.

Chapter10:Datastructures

Fig10.1:Datastructures

structstudent

introllno;

charname[20];

Lineardatastructure

Alineardatastructuretraversesthedataelementssequentially,inwhichonlyonedataelementcandirectlybereached.Ex:Arrays,LinkedLists

Arrays

Arraysrefertoanamedlistofsimilardataelements.Eachoftheelementscanbereferencedbyindexes.

inta[10];� Referstoanarrayof10integers

Structures

Structurereferstocollectionofvariablesofdifferentdatatypes.

Stacks

Stackdatastructuresrefertothelistsstoredandaccessedinlastinfirstout(LIFO).Insertionsanddeletionstakeplaceatonlyatoneendcalledthetop.

Queues

Queuesarefirstinfirstoutlists,whereinsertionstakeplaceattherearendofthequeuesanddeletionstakeplaceatthefrontend.

LinkedLists

Eachelementiscalledanodeandislinkedtoanotherelement(node).Eachnodehas2partsINFOandPTR.INFOcontainsinformationandPTRisapointertothenextnode.

Non-Lineardatastructure

Everydataitemisattachedtoseveralotherdataitemsinawaythatisspecificforreflectingrelationships.Thedataitemsarenotarrangedinasequentialstructure.Ex:Trees,Graphs.

Treesaremultileveldatastructureshavingahierarchicalrelationshipamongitselementscallednodes.Topmostnodeiscalledrootofthetreeandbottommostnodesarecalledleavesofthetree.

Graphs

Atreeonlyallowsanodetohavechildren,andtherecannotbeanyloopsinthetree,withamoregeneralgraphwecanrepresentmanydifferentsituations.

Implementationoflistsinmemory

Pythonlistsarearraysofvariablelength.AlistinPythonisanarrayofpointersofaspecificsize.Itoccupies4bytesin32-bitmachineand8bytesin64-bitmachine.

AlgorithmsonListOperations

Traversal

a)Thefor-instatementmakesiteasytoloopovertheitemsinalist:

foriteminL:

printitem

b)Ifweneedboththeindexandtheitem,weusetheenumeratefunction:

forindex,iteminenumerate(L):

printindex,item

c)Ifweneedonlytheindex,userangeandlen:

forindexinrange(len(L)):

printindex

Insertion

appendmethodaddsasingleitemtotheendofthelist

extendmethodaddsitemsfromanotherlist(oranysequence)totheend

insertinsertsanitematagivenindex,andmovetheremainingitemstotheright.

L.append(item)

L.extend(sequence)

L.insert(index,item)

Deletion

Thedelstatementcanbeusedtoremoveanindividualitem,ortoremoveallitemsidentifiedbyaslice.

Thepopmethodremovesanindividualitemandreturnsit

delL[i]

delL[i:j]

item=L.pop()#lastitem

item=L.pop(0)#firstitem

item=L.pop(index)

L.remove(item)

ArraySearching

Alinearsearchlooksdownalist,oneitematatime,withoutjumping.

Program:

Theinoperatorcanbeusedtocheckifanitemispresentinthelist:

ifvalueinL:

print“listcontains”,value

Togettheindexofthefirstmatchingitem,useindex:

i=L.index(value)

Theindexmethoddoesalinearsearch,andstopsatthefirstmatchingitem.Ifnomatchingitemisfound,itraisesaValueErrorexception.

i=L.index(value)

exceptValueError:

i=-1#nomatch

Togettheindexforallmatchingitems,youcanusealoop,andpassinastartindex:

while1:

i=L.index(value,i+1)

print“matchat”,i

exceptValueError:

Abinarysearchiswhenwestartwiththemiddleofasortedlist,andseewhetherthat’sgreaterthanorlessthanthevaluewe’relookingfor,whichdetermineswhetherthevalueisinthefirstorsecondhalfofthelist.Jumptothehalfwaythroughthesublist,andcompareagainetc.Thisissimilartohumanstypicallylookupawordinadictionary.

complexity-O(logn)

Program:

defbinary_search(nums,x):

high=len(nums)

whilelow<high:

mid=(low+high)//2

midval=nums[mid]

ifmidval<x:

low=mid+1

elifmidval>x:

high=mid

returnmid

return-1

#Getthesortedlist

nums=[]

print“Enterthenumberstosortpress-1toquit”

whileTrue:

number=int(raw_input(“Enternumber?”))

ifnumber<>-1:

nums.append(number)

nums.sort()

printnums

#CallBinsearchfunction

x=int(raw_input(“Enternumbertobesearched”))

pos=binary_search(nums,x)

ifpos<>-1:

printx,“foundatposition”,pos

printx,“notfound”

ArraySortingBubbleSort

Bubble sort is a simple sorting algorithm that works by repeatedly steppingthrough the list to be sorted, comparing each pair of adjacent itemsand swapping them if they are in the wrong order. The pass through the list isrepeated until no swaps are needed, which indicates that the list is sorted. Thealgorithmgetsitsnamefromthewaysmallerelements“bubble”tothetopofthelist.Because itonlyusescomparisons tooperateonelements, it isacomparison

sort.Althoughthealgorithmissimple,mostotheralgorithmsaremoreefficientforsortinglargelists.

Program:

#BubbleSort

defbubble_Sort(numbers):

l=len(numbers)

foriinrange(l):

forjinrange(i,l):

ifnumbers[i]>numbers[j]:

numbers[i],numbers[j]=numbers[j],numbers[i]

print“LISTAFTERSORTING”,numbers

numbers=[90,78,20,46,54,1]

print“LISTBEFORESORTING”,numbers

bubble_Sort(numbers)

names=[‘Neena’,‘Meeta’,‘Geeta’,‘Reeta’,‘Seeta’]

print“LISTBEFORESORTING”,names

bubble_Sort(names)

SelectionSort

Selectionsortperformsthefollowingsteps:1)Startingatindex0,searchtheentirearraytofindthesmallestvalue2)Swapthesmallestvaluefoundwiththevalueatindex03)Repeatsteps1&2startingfromthenextindex

Inotherwords,we’regoingtofindthesmallestelementinthearray,andputitinthefirstposition.Thenwe’regoingtofindthenextsmallestelement,andputitinthesecondposition.Thisprocesswillberepeateduntilwerunoutofelements.Hereisanexampleofthisalgorithmworkingon5elements.Let’sstartwithasamplearray:

{30,50,20,10,40}

First,wefindthesmallestelement,startingfromindex0:

{30,50,20,10,40}

Wethenswapthiswiththeelementatindex0:

{10,50,20,30,40}

Nowthatthefirstelementissorted,wecanignoreit.Consequently,wefindthesmallestelement,startingfromindex1:

{10,50,20,30,40}

Andswapitwiththeelementinindex1:

{10,20,50,30,40}

Findthesmallestelementstartingatindex2:

{10,20,50,30,40}

{10,20,30,50,40}

Findthesmallestelementstartingatindex3:

{10,20,30,50,40}

{10,20,30,40,50}

Finally,findthesmallestelementstartingatindex4:

{10,20,30,40,50}

Andswapitwiththeelementinindex4(nochange)

{10,20,30,40,50}

Program:

defSelSort(nums):

n=len(nums)

#Findthesmallestiteminnums[0]…nums[n-1]

foriinrange(n-1):

pointer=i

forjinrange(i+1,n):

if(nums[j]<nums[pointer]):

pointer=j

nums[i],nums[pointer]=nums[pointer],nums[i]

print“Listaftersorting”

printnums

nums=[]

sortedlist=[]

print“Enterthenumberstosortpress-1toquit”

whileTrue:

number=int(raw_input(“Enternumber?”))

ifnumber<>-1:

nums.append(number)

print“Listbeforesorting”

printnums

#Callselectionsortmethod

SelSort(nums)

InsertionSort

Every repetition of insertion sort removes an element from the input data,inserting it into the correct position in the already-sorted list, until no inputelements remain. The choice of which element to remove from the input isarbitraryandcanbemadeusingalmostanychoicealgorithm.It’sthesamestrategythatweuseforsortingourbridgehand.Wepickupacard,startatthebeginningofourhandandfindtheplacetoinsertthenewcard,insertitandmovealltheothersuponeplace.

Program:

definsertion_sort(numbers):

forKinrange(1,len(numbers)):

temp=numbers[K]

ptr=K-1

while(ptr>=0)andnumbers[ptr]>temp:

numbers[ptr+1]=numbers[ptr]

ptr=ptr-1

numbers[ptr+1]=temp

printnumbers

numbers=[15,-5,20,-10,10]

print“LISTBEFORESORTING”,numbers

insertion_sort(numbers)

Stacks

AstackisadatastructurethatallowsaddingandremovingelementsaccordingtotheLast-InFirst-Out(LIFO)principle.Everytimeanelementisadded,itgoesonthetopofthestack;theonlyelementthatcanberemovedistheelementthatwasatthetopofthestack.

Theoperationsperformedonthestackare:

Push:Adding(inserting)newelementontothestack.

Pop:Removing(deleting)anelementfromthestack

Traversal:Printingelementsofthestack

Addingnewelementtothestacklistiscalledpushoperation.Whenthestackisempty,thevalueoftopis-1.Basically,anemptystackisinitializedwithaninvalidsubscript.WheneveraPushoperationisperformed,thetopisincrementedbyoneandthenthenewvalueisinsertedonthetopofthelisttillthetimethevalueoftopislessthanorequaltothesizeofthestack.

Removingexistingelementsfromthestacklistiscalledpopoperation.Herewehavetocheckifthestackisemptybycheckingthevalueoftop.Ifthevalueoftopis-1,thenthestackisemptyandsuchasituationiscalledUnderflow.OtherwisePopoperationcanbeperformedinthestack.Thetopisdecrementedbyoneifanelementisdeletedfromthelist.

Traversalismovingthroughtheelementsofthestack.Ifyouwanttodisplayalltheelementsofthestack,thealgorithmwillbeasfollows:

InPython,pop()andappend()functionsaretheresothereisnoneedtowritethecodetoaddandremoveelementsinthestack.ConsiderthefollowingprogramsthatperformthePushandPopoperationonthestackthroughappend()andpop().

Program

stack=[]

choice=3

whilechoice<>5:

choice=int(raw_input(“1-CREATE2-PUSH3-POP4-VIEW5-EXIT”))

ifchoice==1:

print“CreatingStack”

whileTrue:

print“EntertheelementsofStackenter-1whendone”

n=int(raw_input(“Enterelement?”))

ifn<>-1:

stack.append(n)

elifchoice==2:

ch=‘y’

print“PerformingPUSH”

whilech==‘y’:

n=int(raw_input(“Enternumbertobeinserted?”))

stack.append(n)

ch=raw_input(“Aretheremorenumbers?y-yesn-no”)

elifchoice==3:

ch=‘y’

print“PerformingPOP”

whilech==‘y’:

stack.pop()

ch=raw_input(“ContinuePopping?y-yesn-no”)

elifchoice==4:

print“STACKCONTENTSARE”

printstack

Applicationofstacks1. Expressionevaluation

2. Backtracking(gameplaying,findingpaths,exhaustivesearching)

3. Memorymanagement,run-timeenvironmentfornestedlanguagefeatures.

Expressionevaluation

Weareaccustomedtowritearithmeticexpressionswiththeoperationbetweenthetwooperands:a+borc/d.Ifwewritea+b*c,however,wehavetoapplyprecedencerulestoavoidtheambiguousevaluation(addfirstormultiplyfirst?).Postfixexpressionsareeasilyevaluatedwiththeaidofastack.

PostfixEvaluationAlgorithm

Assumewehaveastringofoperandsandoperators,aninformal,byhandprocessis

1.Scantheexpressionlefttoright

2. Skipvaluesorvariables(operands)

3. Whenanoperatorisfound,applytheoperationtotheprecedingtwooperands

4. Replacethetwooperandsandoperatorwiththecalculatedvalue(threesymbols

arereplacedwithoneoperand)

5. Continuescanninguntilonlyavalueremains—theresultoftheexpression

Letusseehowtheabovealgorithmwillbeimplementedusinganexample.

Example:AB+C*D/

IfA=2,B=3,C=4,D=5

InfixtransformationtoPostfix

Thisprocessusesastack.Wehavetoholdinformationthat’sexpressedinsideparentheseswhilescanningtofindtheclosing‘)’.Wealsohavetoholdinformationonoperationsthatareoflowerprecedenceonthestack.

Thealgorithmis:

1.Createanemptystackandanemptypostfixoutputstring/stream

2. Scantheinfixinputstring/streamlefttoright

3. Ifthecurrentinputtokenisanoperand,simplyappendittotheoutputstring(notetheexamplesabovethattheoperandsremaininthesameorder)

4. Ifthecurrentinputtokenisanoperator,popoffalloperatorsthathaveequalorhigherprecedenceandappendthemtotheoutputstring;pushtheoperatorontothestack.Theorderofpoppingistheorderintheoutput.

5. Ifthecurrentinputtokenis‘(‘,pushitontothestack

6. Ifthecurrentinputtokenis‘)’,popoffalloperatorsandappendthemtotheoutputstringuntila‘(‘ispopped;discardthe‘(‘.

7. Iftheendoftheinputstringisfound,popalloperatorsandappendthemtotheoutputstring.

Thisalgorithmdoesn’thandleerrorsintheinput,althoughcarefulanalysisofparenthesisorlackofparenthesiscouldpointtosucherrordetermination.

Example:ConvertA+(B*C–(D/E^F)*G)*Hintopostfixformshowingstackstatusaftereverystepintabularform

S.No Element Stack Expression

1 A ( A

2 + (+ A

3 ( (+( A

4 B (+( AB

5 * (+(* AB

6 C (+(* ABC

7 - (+(- ABC*

8 ( (+(-( ABC*

9 D (+(-( ABC*D

10 / (+(-(\ ABC*D

11 E (+(-(\ ABC*DE

12 ^ (+(-(\^

ABC*DE

13 F (+(-(\^

ABC*DEF

14 ) (+(- ABC*DEF^/

15 * (+(-* ABC*DEF^/

16 G (+(-* ABC*DEF^/G

17 ) (+ ABC*DEF^/G*-

18 * (+* ABC*DEF^/G*-

19 H (+* ABC*DEF^/G*-H

20 ) ABC*DEF^/G*-H*+

Queueisafirst-in,first-out(FIFO)datastructure.i.e.theelementaddedfirsttothequeuewillbetheonetoberemovedfirst.Elementsarealwaysaddedtotherearofthequeueandremovedfromthefrontofthequeue.

Iffront=0,thenqueueisempty

Theno.ofelementsinthequeueisgivenby

N=front–rear+1

Program:

queue=[]

choice=3

whilechoice<>5:

choice=int(raw_input(“1-CREATE2-INSERT3-DELETE4-VIEW5-EXIT”))

ifchoice==1:

print“CreatingQueue”

whileTrue:

print“EntertheelementsofQueueenter-1whendone”

n=int(raw_input(“Enterelement?”))

ifn<>-1:

queue.append(n)

elifchoice==2:

ch=‘y’

print“PerformingINSERT”

whilech==‘y’:

n=int(raw_input(“Enternumbertobeinserted?”))

queue.append(n)

ch=raw_input(“Aretheremorenumbers?y-yesn-no”)

elifchoice==3:

ch=‘y’

print“PerformingDELETE”

whilech==‘y’:

queue.pop(0)

ch=raw_input(“Continuedelete?y-yesn-no”)

elifchoice==4:

print“QUEUECONTENTSARE”

printqueue

Deque(Double-endedqueues)

Dequesare the refined queueswhich allows insertions and deletions at bothendsofthelist.Theyareof2types

Inputrestricteddeques–allowsinsertionsatoneendonly

Outputrestricteddeques–allowsdeletionsatoneendonly

CircularQueues

Circular Queues are the queues implemented in circular form rather than astraightline.Thecircularqueueconsidersitselfcontiguousatoppositeends.Thatiswhy if space is there in the beginning, the rear shifts back to beginning afterreachingthemaxsize.

SolvedExamples

1.Defineadatastructure.

Ans.Adatastructureisagroupofdatawhichcanbeprocessedasasingleunit.Thisgroupofdatamaybeofsimilarordissimilardatatypes.DataStructuresareveryusefulwhileprogrammingbecausetheyallowprocessingoftheentiregroupofdataasasingleunit.

2.GiveonepointofdifferencebetweenanarrayandalistinPython.

Ans.Anarrayisdefinedasasetofcontiguousdataofsimilardatatype.Pythonlistsareactuallyarraysofvariablelength.Theelementsofalistareofheterogeneoustypeswhichmeanstheyareofdifferentdatatypes

3.HowismemoryallocatedtoalistinPython?

Ans.AlistinPythonisanarraythatcontainselements(pointerstoobjects)ofaspecificsizeonlyandthisisacommonfeatureofalldynamicallytypedlanguages.Forimplementationofalist,acontiguousarrayofreferencestootherobjectsisused.Pythonkeepsapointertothisarrayandthearray’slengthisstoredinalistheadstructure.Thismakesindexingofalistindependentofthesizeofthelistorthevalueoftheindex.Whenitemsareappendedorinserted,thearrayofreferencesisresized.

4.Howislinearsearchdifferentfrombinarysearch?

Binarysearchrequirestheinputdatatobesorted;linearsearchdoesn’t

Binarysearchrequiresanorderingcomparison;linearsearchonlyrequiresequalitycomparisons

BinarysearchhascomplexityO(logn);linearsearchhascomplexityO(n)asdiscussedearlier

Binarysearchrequiresrandomaccesstothedata;linearsearchonlyrequiressequentialaccess(thiscanbeveryimportant-itmeansalinearsearchcanstreamdataofarbitrarysize)

5.Writeaprogramtogetalistofnumbersandanumbertobesearchedandprintitspositioninthelist.

maxrange=input(“EnterCountofnumbers:“)

marks=[]

flag=False

marks.append(input(“?”))

number=input(“Enternumbertobesearched”)

ifmarks[i]==number:

printnumber,“foundatposition”,i

flag=True

ifflag==False:

printnumber,“notfoundinlist”

6.Writeafunctionthattakesalistthatissortedinascendingorderandanumberasarguments.Thefunctionshoulddothefollowing:

a.Insertthenumberpassedasargumentinasortedlist.

b.Deletethenumberfromthelist.

frombisectimportbisect

deflistfunc(sortedlist,number):

insert_point=bisect(sortedlist,number)

sortedlist.insert(insert_point,number)

print“ListafterInsertion”

printsortedlist

sortedlist.remove(number)

print“ListafterDeletion”

printsortedlist

numlist=[]

flag=False

numlist.append(input(“?”))

numlist.sort()

number=input(“Enterthenumber”)

listfunc(numlist,number)

7.Writeafunctionforbinarysearch.

defbinary_search(SORTEDLIST,number):

high=len(SORTEDLIST)

found=False

while(low<high)andfound==False:

mid=(int)(low+high/2)

ifSORTEDLIST[mid]==number:

print“Numberfoundat”,mid

found=True

elifSORTEDLIST[mid]<number:

low=mid+1

high=mid-1

iflow>=high:

print“Numbernotfound”

numlist=[]

numlist.append(input(“?”))

numlist.sort()

print“Sortedlist”,numlist

number=input(“Enterthenumber”)

binary_search(numlist,number)

8.Inthefollowinglistcontainingintegers,sortthelistusingInsertionsortalgorithm.Alsoshowthestatusofthelistaftereachiteration.

10,-2,6,-1,5

definsertion_sort(NUMLIST):

forKinrange(1,len(NUMLIST)):

temp=NUMLIST[K]

ptr=K-1

while(ptr>=0)andNUMLIST[ptr]>temp:

NUMLIST[ptr+1]=NUMLIST[ptr]

ptr=ptr-1

NUMLIST[ptr+1]=temp

printNUMLIST

NUMLIST=[10,-2,6,-1,5]

print“LISTBEFORSORTING”,NUMLIST

insertion_sort(NUMLIST)

LISTBEFORSORTING[10,-2,6,-1,5]

[-2,10,6,-1,5]

[-2,6,10,-1,5]

[-2,-1,6,10,5]

[-2,-1,5,6,10]

9. Writeaprogramtosortalistcontainingnamesofstudentsinascendingorder

usingselectionsort.

defselection_sort(NUMLIST):

foriinrange(0,len(NUMLIST)):

forjinrange(i+1,len(NUMLIST)):

ifDATA_LIST[j]<NUMLIST[min]:

#swapping

temp=NUMLIST[min]

NUMLIST[min]=NUMLIST[i]

NUMLIST[i]=temp

printNUMLIST

NAME_LIST=[‘Neena’,‘Beeta’,‘Reeta’,‘Geeta’,‘Seeta’]

print“LISTBEFORESORTING”,NAME_LIST

selection_sort(NAME_LIST)

LISTBEFORESORTING[‘Neena’,‘Beeta’,‘Reeta’,‘Geeta’,‘Seeta’]

[‘Beeta’,‘Neena’,‘Reeta’,‘Geeta’,‘Seeta’]

[‘Beeta’,‘Geeta’,‘Reeta’,‘Neena’,‘Seeta’]

[‘Beeta’,‘Geeta’,‘Neena’,‘Reeta’,‘Seeta’]

10.Considerthefollowingunsortedlist

90782046541

Writethelistafter:

a.3rditerationofselectionsort

b.4thiterationofbubbleort

c.5thiterationofinsertionsort

Working

Bubblesort SelectionSort Insertionsort

[1,90,78,46,54,20]

[1,20,90,78,54,46]

[1,20,46,90,78,54]

[1,20,46,54,90,78]

[1,20,46,54,78,90]

[1,78,20,46,54,90]

[1,20,78,46,54,90]

[1,20,46,78,54,90]

[1,20,46,54,78,90]

[78,90,20,46,54,1]

[20,78,90,46,54,1]

[20,46,78,90,54,1]

[20,46,54,78,90,1]

[1,20,46,54,78,90]

a.3rditerationofselectionsort:[1,20,46,78,54,90]

b.4thiterationofbubblesort:[1,20,46,54,90,78]

c.5thiterationofinsertionsort:[1,20,46,54,78,90]

11.Expandthefollowing:

(i)LIFO(ii)FIFO

LIFO:Last-InFirst-Out

FIFO:First-InFirst-Out

12.Whatisstack?

Ans. A stack is a data structure that allows adding and removing elements in aparticularorder.Everytimeanelementisadded,itgoesonthetopofthestack;theonlyelementthatcanberemovedistheelementthatwasatthetopofthestack.

13.WhatisQueue?

Ans.Queueisafirst-in,first-out(FIFO)datastructure.i.e.theelementaddedfirsttothequeuewillbetheonetoberemovedfirst.Elementsarealwaysaddedtotherearofthequeueandremovedfromthefrontofthequeue.

14.Giveoneexampleeachofinfix,postfixandprefixexpression.

Infix:A+B*C/D

Postfix:ABC*D/+

Prefix:+/*BCDA

15.Whatistheadvantageofpostfixexpressions?

Ans:Aninfixexpressionisdifficultforthemachinetoknowandkeeptrackofprecedenceofoperators.Apostfixexpressionitselfdeterminestheprecedenceofoperatorssoitiseasierforthemachinetocarryoutapostfixexpressionthananinfixexpression.

16.Whataretheadvantagesofcircularqueues?

Ans:Incircularqueuesmemoryisutilizedefficiently.Inqueuewhenwedeleteanyelementonlyfrontincrementsby1butthatpositionisnotusedlater.Whenweperformmoreaddanddeleteoperationmemorywastageincreases.Butincircularqueuememoryisutilizedifwedeleteanyelementthatpositionisusedlaterbecauseitiscircular.

17.Considerthefollowingcircularqueuewithacapacityof6elements:Front=2rear=4;

Describethequeueasthefollowingoperationstakeplace.

a)AddD,E

b)Delete2letters

c)AddX,Y,Z

a)Front=2Rear=6

b)Front=4Rear=6

c)Front=4Rear=(6+3)mod6=3

18.EvaluatethefollowingBooleanpostfixexpressionshowingstackstatusaftereverystep:True,False,True,AND,OR,False,NOT,AND

19.Evaluateusingstack10,3,*,30,2,*,-

20.ConvertA+(B*C–(D/E^F)*G)*Hintopostfixformshowingstackstatusaftereverystep.

S.No Element Stack Expression

1 A ( A

2 + (+ A

3 ( (+( A

4 B (+( AB

5 * (+(* AB

6 C (+(* ABC

7 - (+(- ABC*

8 ( (+(-( ABC*

9 D (+(-(

10 / (+(-(\

11 E (+(-(\

ABC*DE

12 ^ (+(-(\^

ABC*DE

13 F (+(-(\^

ABC*DEF

14 ) (+(- ABC*DEF^/

15 * (+(-*

ABC*DEF^/

16 G (+(-*

ABC*DEF^/G

17 ) (+ ABC*DEF^/G*-

18 * (+* ABC*DEF^/G*-

19 H (+* ABC*DEF^/G*-H

20 ) ABC*DEF^/G*-H*+

21.Whataretheapplicationsofqueueincomputer?

1. Inasingleprocessormultitaskingcomputer,job(s)waitingtobeprocessedformaqueue.Samehappenswhenweshareaprinterwithmanycomputers.

2. CompilingaHLLcode3. Usingdownloadmanager,formultiplefilesalsousesqueuefororderingthefiles.4. InmultiuserOS-jobschedulingisdonethroughqueue.

22.Writeafunctiontopushanystudent’sinformationtostack.

defpush(stack):

print“STACKBEFOREPUSH”

display(stack)

s.append(input(“Enterstudentrollno?”))

s.append(raw_input(“Enterstudentname”))

s.append(raw_input(“Enterstudentgrade”))

stack.append(s)

defdisplay(stack):

l=len(stack)

print“STACKCONTENTS”

foriinrange(l-1,-1,-1):

printstack[i]

stack=[]

print“CreatingStack”

n=input(“Enterthenumberofstudents”)

foriinrange(n):

student=[]

student.append(input(“Enterstudentrollno?”))

student.append(raw_input(“Enterstudentname”))

student.append(raw_input(“Enterstudentgrade”))

stack.append(student)

push(stack)

display(stack)

23.Writethepushoperationofstackcontainingnamesusingclass.

classstack:

defpush(self):

a=raw_input(“Enteranyname:”)

stack.s.append(a)

defdisplay(self):

l=len(stack.s)

printstack.s[i]

a=stack()

n=input(“Enterno.ofnames”)

foriinrange(n):

a.push()

a.display()

24.Writethepopoperationofstackcontainingnamesusingclass.

classstack:

defpush(self):

a=raw_input(“Enteranyname:”)

stack.s.append(a)

defpop(self):

if(a.s==[]):

print“StackEmpty”

print“Deletedelementis:“,a.s.pop()

defdisplay(self):

l=len(stack.s)

printstack.s[i]

a=stack()

foriinrange(n):

a.push()

a.pop()

a.display()

25. Writeafunctiontoaddanycustomer’sinformationtoqueue.

definsert(queue):

customer=[]

print“QUEUEBEFOREINSERT”

display(queue)

customer.append(input(“Entercustomernumber?”))

customer.append(raw_input(“Entercustomername”))

customer.append(input(“Entercustomerphonenumber”))

queue.append(customer)

defdisplay(queue):

l=len(queue)

foriinrange(0,l):

printqueue[i]

queue=[]

print“CreatingQueue”

n=input(“Enterthenumberofcustomers”)

foriinrange(n):

customer=[]

customer.append(input(“Entercustomernumber?”))

customer.append(raw_input(“Entercustomername”))

customer.append(input(“Entercustomerphonenumber”))

queue.append(customer)

insert(queue)

display(queue)

26.Writethedeletionoperationofqueuecontainingnumbersusingclass.

classqueue:

definsert(self):

a=input(“Enterthenumber:”)

queue.s.append(a)

defdelete(self):

if(a.s==[]):

print“QueueEmpty”

print“Deletedelementis:“,queue.s[0]

delqueue.s[0]

defdisplay(self):

l=len(queue.s)

print“QUEUECONTENTS”

foriinrange(0,l):

printqueue.s[i]

a=queue()

n=input(“Enterno.ofnumbers”)

foriinrange(n):

a.insert()

a.delete()

a.display()

PracticeQuestions1. Writeaprogramtosortalistofitemsusingbubblesort.Useclassestostoreitem

details.2. Writeapythonprogramtosortalistofnumbersusinginsertionsortalgorithm.

3.Convertthefollowinginfixexpressiontoitsequivalentpostfixexpressionshowingstackcontentsfortheconversion:

a)A+B*(C–D)/E^F

b)(A+B)*(C^(D-E)+F)-G

4.Evaluatethefollowingpostfixnotationofexpression:(Showstatusofstackafterexecutionofeachoperation):

a)20,30,+,50,40,-,*

b)5,20,15,-,*,25,2,*,+

5.WriteacompleteprograminPythontoimplementadynamicallyallocatedqueuecontainingnamesofcities.

6.Writethepopoperationofstackcontainingnumbersusingclass.

7.Writeaprogramtomaintainastackofbooks.

8. Writeaprogramtosimulateareservationqueueusingclasses.

Chapter11:DATAFILEHANDLING

Wehavedonealotofprogrammingwherewehavestoreddatainlistsordictionaries.Thedataenteredisstoredinprimarymemorywhichisatemporarymemory.

Let’ssayforexamplethatwearegeneratingastudent’sreportcard.Itwouldbeniceifthedataisstoredinpermanentstorage.Filesareusedtostoredatapermanently.Afileisabunchofbytesstoredonsomestoragedeviceliketape,magneticdisketc.Thereare2typesoffiles.

TextfileisafilethatstoresinformationinASCIIcharacters.Intextfiles,eachline of text is terminatedwith a special character known as EOL (End of Line)characterordelimitercharacter.WhenthisEOLcharacterisreadorwritten,certaininternaltranslationstakeplace.

Binaryfileisafilethatcontainsinformationinthesameformatasitisheldinmemory.Inbinaryfiles,nodelimitersareusedforalineandnotranslationsoccurhere.So,binaryfilesarefasterandoccupylesserstoragespace.

OpenFunction

Itcreatesafileobjectwhichwouldbeutilizedtocallothersupportmethodsassociatedwithit.

fileobject=open(filename[,access_mode][,buffering])

filename:Thefile_nameargumentisastringvaluethatcontainsthenameofthefilethatyouwanttoaccess.

access_mode:Theaccess_modedeterminesthemodeinwhichthefilehastobeopenedie.read,writeappendetc.Acompletelistofpossiblevaluesisgivenbelowinthetable.Thisisoptionalparameterandthedefaultfileaccessmodeisread(r)

buffering:Ifthebufferingvalueissetto0,nobufferingwilltakeplace.Ifthebufferingvalueis1,linebufferingwillbeperformedwhileaccessingafile.Ifyouspecifythebufferingvalueasanintegergreaterthan1,thenbufferingactionwillbeperformedwiththeindicatedbuffersize.Ifnegative,thebuffersizeisthesystemdefault(defaultbehavior).

FileopeningModes

Modes Description

r Opensafileforreadingonly.Thefilepointerisplacedatthebeginningofthefile.Thisisthedefaultmode.

rb Opensafileforreadingonlyinbinaryformat.Thefilepointerisplacedatthebeginningofthefile.Thisisthedefaultmode.

r+ Opensafileforbothreadingandwriting.Thefilepointerwillbeatthebeginningofthefile.

rb+ Opensafileforbothreadingandwritinginbinaryformat.Thefilepointerwillbeatthebeginningofthefile.

w Opensafileforwritingonly.Overwritesthefileifthefileexists.Ifthefiledoesnotexist,

createsanewfileforwriting.

wb Opensafileforwritingonlyinbinaryformat.Overwritesthefileifthefileexists.Ifthefiledoesnotexist,createsanewfileforwriting.

w+ Opensafileforbothwritingandreading.Overwritestheexistingfileifthefileexists.Ifthefiledoesnotexist,createsanewfileforreadingandwriting.

wb+ Opensafileforbothwritingandreadinginbinaryformat.Overwritestheexistingfileifthefileexists.Ifthefiledoesnotexist,createsanewfileforreadingandwriting.

a Opensafileforappending.Thefilepointerisattheendofthefileifthefileexists.Thatis,thefileisintheappendmode.Ifthefiledoesnotexist,itcreatesanewfileforwriting.

ab Opensafileforappendinginbinaryformat.Thefilepointerisattheendofthefileifthefileexists.Thatis,thefileisintheappendmode.Ifthefiledoesnotexist,itcreatesanewfileforwriting.

a+ Opensafileforbothappendingandreading.Thefilepointerisattheendofthefileifthefileexists.Thefileopensintheappendmode.Ifthefiledoesnotexist,itcreatesanewfileforreadingandwriting.

ab+ Opensafileforbothappendingandreadinginbinaryformat.Thefilepointerisattheendofthefileifthefileexists.Thefileopensintheappendmode.Ifthefiledoesnotexist,it

createsanewfileforreadingandwriting.

Thefileobjectatrributes

Oncea file isopenedandyouhaveone fileobject,youcangetvarious informationrelatedtothatfile.Hereisalistofallattributesrelatedtofileobject:

Attribute Description

file.closed Returnstrueiffileisclosed,falseotherwise.

file.mode Returns access mode with which file wasopened.

file.name Returnsnameofthefile.

file.softspace Returns false if space explicitly required withprint,trueotherwise.

Openingafile

Method1:

file=open(“Test.txt”,“r+”)

willopenafilecalledTest.txtforreadingandwritingpurpose.

Wecanuseavariableinsteadofaconstantasnameofthefile.

filename=raw_input(“Enterfilename”)

File=open(filename,“r”)

Thefilehastobeinthesamefolderwhereweareworkingnow,otherwisewehavetospecifythecompletepath.

Method2:

F=file(“Test”,”w”)

Method3:

withstatementcanalsobeusedforsamepurpose.Usingwithensuresthatalltheresourcesallocatedtofileobjectsgetsdeallocatedautomaticallyoncewestopusingthefile.Itssyntaxis:

withopen()asfileobject:

Example:

withopen(“Test.txt”,“r+”)asfile:

……………..

FileMethods

S.No Methods Description Example

1 close() Closethefile. fileobject.close()

2 flush()

Flushtheinternalbuffer

fileobject.flush()

3 next()

Returnsthenextlinefromthefileeachtimeitisbeingcalled.

fileobject.next()

4 read([size]) Readsatmostsizebytesfromthefile

X=fileobject.read([size])

5 readline([size])

Readsoneentirelinefromthefile.Atrailingnewlinecharacteriskeptinthestring.

X=fileobject.readline()

6 readlines([size]) ReadsuntilEOFusingreadline()andreturnalistcontainingthelines.Ifsizehintargumentispresent,lines

X[]=fileobject.readlines()

totallingapproximatelysizehintbytesareread.

7 seek(offset[,pos])

Setsthefile’scurrentposition.

fileobject.seek(5)

8 tell()

Returnsthefile’scurrentposition

fileobject.tell()

9 truncate([size])

Truncatesthefile’ssize.

fileobject.truncate()

10 write(str)

Writesastringtothefile.

str=“Hello”

fileobject.write(str)

11 writelines(sequence)

Writesasequenceofstringstothefile.

strlist=[‘I’,‘love’,‘Python’]

Fileobject.writelines(strlist)

Fromtheabovetableonfilemethods,readlines()willgetallthelinesofthefileasalist(orsequence).Towriteinafileweusewriteandwritelinesmethod.

osmodulefunctionsSomeoftheusefulmethods,whichcanbeusedwithfilesinosmoduleareasfollows:

1.getcwd()–givesthenameofcurrentworkingdirectory

2.path.abspath(filename)-givesusthecompletepathnameofthedatafile.

3.path.isfile(filename)-checkswhetherthefileexistsornot.

4.remove(filename)-deletesthefile.

5.rename(filename1,filename2)-changesthenameoffilename1withfilename2.

Operationsontextfiles

Writing/Creatingatextfile

file=open(“input.txt”,’w’)

whileTrue:

line=raw_input(“Entertheline”)

file.write(line)

choice=raw_input(“Doyouhavemorelines?YorN”)

ifchoice==‘N’:

file.close()

Theabovecodewouldcreateafile“input.txt”.Itwouldgetlinesfromtheuserandwriteitintothefile.

Readingfromatextfile

file=open(“input.txt”,’r’)

lines=file.readlines()

file.close()

forlineinlines:

printline

Theabovecodewouldopenthefileandreadtheentirecontentsofthefileintothelist–lines.Wecanthenuseaforlooptoprintthecontentsofthelist.

Traversal/Display

forlineinopen(“story.txt”,“r”).readlines():

printline

file.close()

Deletion

withopen(‘story.txt’,‘r’)asfile:

l=file.readlines()

file.close()

printl

lineno=input(“Enterthelinenumbertobedeleted”)

dell[lineno]

printl

file.open(‘story.txt’,‘w’)

file.writelines(l)

file.close()

Updation

withopen(“data.txt”,“r”)asfile:

contents=file.readlines()

file.close()

forlineincontents:

printline

ch=raw_input(“Doyouwanttochangethisline?”)

ifch==‘Y’:

newline=raw_input(“Enterthenewline”)

contents[i]=newline

withopen(“data.txt”,“w”)asfile:

file.writeline(contents)

printcontents

RandomAccess

tell()methodreturnsanintegergivingthecurrentpositionofobjectinthefile.Theintegerreturnedspecifiesthenumberofbytesfromthebeginningofthefiletillthecurrentpositionoffileobject.

Syntax:f.tell()

seek()methodcanbeusedtopositionthefileobjectatparticularplaceinthefile.

Syntax:f.seek(offset[,pos])

hereoffsetisusedtocalculatethepositionoffileobjectinthefileinbytes.Offsetisaddedtopos(referencepoint)togettheposition.Followingisthelistofposvalues:

Valuereferencepoint

0beginningofthefile

1currentpositionoffile

2endoffile

defaultvalueofposis0,i.e.beginningofthefile

Example:

>>>f.tell()#getthecurrentfileposition

>>>f.seek(0)#bringfilecursortoinitialposition

>>>print(f.read())#readtheentirefile

ThisisaPythonfile

Thisexplainsabout

seek()

tell()

Binaryfiles

Serializationistheprocessofconvertingadatastructure/objectthatcanbestoredinnonstringformatandcanberesurrectedlater.Serializationcanalsobecalledasdeflatingthedataandresurrectingasinflatingit.

Picklemoduleisusedinserializationofdata.Itallowustostoredatainbinaryforminthefile.Dumpandloadfunctionsareusedtowritedataandreaddatafromfile.

Writinginabinaryfile

importpickle#step1

file=open(‘data.dat’,‘wb’)#step2

whileTrue:

x=int(raw_input(“Enternumber”))#step3

pickle.dump(x,file)#step4

ans=raw_input(‘wanttoentermoredataY/N’)

ifans.upper()==‘N’:break

file.close()#step5

Readingfromabinaryfile

importpickle#step1

file=open(‘data.dat’,‘rb’)#step2

whileTrue:

y=load(file)#step3

printy#step4

exceptEOFError:#Endoffileerror

file.close()#step5

BinaryfileManipulation

Letustakeanexampleofaninventorysystem.Weneedtoimporttherequiredmodules

frompickleimportload,dump

importos

importsys

Thenextstepistocreatetheclasswiththerequiredattributes.Inthiscase,weneedtocreateanitemclasswithattributeslikeiemcode,itemname,priceandqty.Wehavealsodefinedthegetanddisplayfunctions.

classITEM:

def__init__(self):

self.itemcode=0

self.itemname=”

self.price=0.0

self.qty=0

defget(self):

self.itemcode=input(“Enteritemcode”)

self.itemname=raw_input(“Enteritemname”)

self.price=float(raw_input(“Enterprice”))

self.qty=input(“Enterquantity”)

defdisplay(self):

print“ItemCode”,self.itemcode

print“ItemName”,self.itemname

print“Price”,self.price

print“Quantity”,self.qty

Letusdefinethefilename

fname=‘ITEM.dat’

choice=0

whilechoice<5:

choice=input(“1-create2-display3-search4-update5-exit”)

ifchoice==1:

ofile=open(fname,‘wb’)

print‘Goingtodump’

num=input(“Enternumberofitems”)

foriinrange(num):

t=ITEM()

t.get()

dump(t,ofile)

ofile.close()

print“Writtenintofile”

Weopenthefilein‘wb’-writebinarymode.Wecalltheget()functiontogetallthedetailsoftheitemfromtheuser.Eachitemisthenwrittenintothefileusingthedump()function.

elifchoice==2:

ifnotos.path.isfile(fname):

print“filedoesnotexist”

ifile=open(fname,‘rb’)

whileTrue:

t=load(ifile)

t.display()

exceptEOFError:

ifile.close()

Fordisplayingthewrittencontentsfromthefile,weopenthefilein‘rb’readbinarymode.Theloadfunctiongetstheitemfromthefileandweusethedisplay()functiontodisplaytheitem.Inasimilarway,tilltheend-of-fileallthecontentsaredisplayedonthescreen.

elifchoice==3:

search=input(“Enteritemcode”)

whileTrue:

t=load(ifile)

ift.itemcode==search:

t.display()

exceptEOFError:

ifile.close()

Tosearchforaparticularitem,

1. Gettheitemcodetobesearched.2. Openthefileinreadmode.

3. Gettheitem4. Iftheitemcode=theitemtobesearchedthedisplaythedetailsoftheitemlike

itemname,priceandquantityordered5. Repeatsteps3&4tillwereachtheendoffile6. Closethefile

elifchoice==4:

ifile=open(fname,‘rb+’)

search=input(“Enteritemcode”)

whileTrue:

#Storethepositionofthefirstbyteofline

pos=ifile.tell()

t=load(ifile)

ift.itemcode==search:

t.itemname=raw_input(“Enternewitemname”)

t.price=float(raw_input(“Enternewprice”))

t.qty=input(“Enternewquantity”)

#Movethefilepointertothestoredposition

ifile.seek(pos)

dump(t,ifile)

print“Updated”

exceptEOFError:

Tomodifyafile,

1. Openthefilein‘rb+’modewhichenablesbothreading&writing2. Gettheitemcodetobemodified

3. Storethepositionofthefirstbyte4. Gettheitem5. Ifitemcode=itemtobemodifiedthen

a)getthenewdetails

b)Movethefilepointertothestartingofthisline

c)Writethenewdetails(Overwrite)

6. Closethefile

SolvedQuestions1. Whatistheuseofread()function?

Ans.Itreadsthewholefileandreturnsthewholethinginastring

2. Whatistheuseofreadline()function?

Ans.readsthefirstlineofthefileandreturnsitasastring

3. Whatistell()method?

Ans.Thetell()methodtellsyouthecurrentpositionwithinthefileinotherwords,thenextreadorwritewilloccuratthatmanybytesfromthebeginningofthefile

4. Whatistheuseofrename()function?

Ans.The rename()method takes two arguments, the current filename and the newfilename.

os.rename(current_file_name,new_file_name)

5. Whatistheuseofremove()function?

Ans.Youcanusetheremove()methodtodeletefilesbysupplyingthenameofthefiletobedeletedastheargument.

os.remove(file_name)

6. Whatistheuseofpicklemodule?

Ans.Picklemodulecanbeusedtostoreanykindofobjectinfileasitallowsustostorepythonobjectswiththeirstructure.Soforstoringdatainbinaryformat,wewillusepicklemodule.

7. Whatistheuseofdumpmethod?

Ans.pickle.dump()writestheobjectinfile,whichisopenedinbinaryaccessmode.

Syntaxofdump()methodis:

dump(object,fileobject)

8. Whatistheuseofloadmethod?

Ans.Forreadingdatafromfilewewillusepickle.load()toreadtheobjectfrompicklefile.

Syntaxofload()is:

object=load(fileobject)

9. Inhowmanywayscanendoffilebedetected?

1. Whenendoffileisreached,readline()willreturnanemptystring.2. try:

whileTrue:

y=pickle.load(file)

—dosomething—

exceptEOFError:

10.Whatisthedifferencebetweentextfilesandbinaryfiles?(or)Whataretheadvantagesofbinaryfiles?

Ans.Aswetalkoflinesintextfile,eachlineisterminatedbyaspecialcharacter,knownasEndofLine(EOL).Textfilesarestoredinhumanreadableformandtheycanalsobecreatedusinganytexteditor.

Abinaryfilecontainsarbitrarybinarydatai.e.numbersstoredinthefile,canbeusedfornumericaloperation(s).Sowhenweworkonbinaryfile,wehavetointerprettherawbitpattern(s)readfromthefileintocorrecttypeofdatainourprogram.Pythonprovidesspecialmodule(s)forencodinganddecodingofdataforbinaryfile.

11.WriteafunctionCountYouMe()inPythonwhichreadsthecontentsofatextfileNotes.txtandcountsthewordsYouandMe(notcasesensitive).

defCountYouMe():

wordlist=[line.strip()forlineinopen(‘notes.txt’)]

#Searchingforawordinafile

count=0

forwordinwordlist:

words=word.split(”“)

forwordinwords:

#Removeallleadingandtrailingwhitespaces

word=word.strip().lower()

ifword==‘you’orword==‘me’:

count=count+1

ifcount==0:

print“notfoundinfile”

print“count=”,count

CountYouMe()

Example:Ifthefilecontains

Youaremybestfriend

Youandmemakeagoodteam.

Outputwouldbe:count=3

12.Writeafunctiontocountthenumberoflinesstartingwithadigitinatextfile“Diary.txt”.

defCountFirstDigit():

count=0

withopen(‘Diary.txt’,‘r’)asf:

whileTrue:

line=f.readline()

ifnotline:break

ifline[0].isdigit():

count=count+1

ifcount==0:

print“nolinestartswithadigit”

CountFirstDigit()

13.GivenaclassTRAINasfollows,

classTRAIN:

def__init__(self):

self.trainno=0

self.trainname=”

self.start=”

self.dest=”

defget(self):

self.trainno=input(“Entertrainnumber”)

self.trainname=raw_input(“Entertrainname”)

self.start=raw_input(“Enterstartingplace”)

self.dest=raw_input(“Enterdestintion”)

defdisplay(self):

print“TrainNumber”,self.trainno

print“TrainName”,self.trainname

print“STARTINGPLACE”,self.start

print“DESTINATION”,self.dest

Writeafunctionto

(i)TowriteanobjectofTRAINtypeintoabinaryfile“TRAIN.dat”

(ii)Tosearchanddisplaydetailsoftrainsstartingfrom“MUMBAI”

(iii)Tosearchanddisplaydetailsoftrainswhosedestinationin“DELHI”

frompickleimportload,dump

importos

importsys

fname=‘TRAIN.dat’

choice=0

whilechoice<5:

choice=input(“1-create2-display3-searchusingstart4-searchusingdest5-exit”)

ifchoice==1:

ofile=open(fname,‘wb’)

num=input(“Enternumberoftrains”)

foriinrange(num):

t=TRAIN()

t.get()

dump(t,ofile)

ofile.close()

elifchoice==2:

ifnotos.path.isfile(fname):

print“filedoesnotexist”

whileTrue:

t=load(ifile)

t.display()

exceptEOFError:

ifile.close()

elifchoice==3:

start=raw_input(“Enterstartingstation”)

whileTrue:

t=load(ifile)

ift.start==start:

t.display()

exceptEOFError:

ifile.close()

elifchoice==4:

dest=raw_input(“Enterdestinationstation”)

whileTrue:

t=load(ifile)

ift.dest==dest:

t.display()

exceptEOFError:

ifile.close()

PracticeQuestions

1.Writeafunctiontoreadthecontentofatextfile“DELHI.txt”anddisplayallthoselinesonscreen,whichareeitherstartingwith‘D’or‘M’.

2.Atextfile“PARA.txt”containsaparagraph.Writeafunctionthatsearchesforagivencharacterandreportstheno.ofoccurrencesofthecharacterinthefile.

3.Createadictionaryhavingdecimalequivalentofromannumerals.Storeitinabinaryfile.Writeafunctiontoconvertromannumbertodecimalequivalentusingthebinaryfiledata.

4.WriteafunctionCountHisHer()inPythonwhichreadsthecontentsofatextfile“Story.txt”andcountsthewordsHisandHer(notcasesensitive).

5.Writeafunctiontocountthenumberoflinesstartingwithuppercasecharactersinatextfile“Help.doc”.

6.Writeaprogramtoacceptafilenamefromtheuseranddisplayallthelinesfromthefilewhichcontainpythoncommentcharacter‘#’.

7. Write a program in Python to insert, delete, search and display details of allemployeesfromabinaryfile“Employee.dat”.

Chapter12:ExceptionHandling&Generators

Anexceptionisanevent,whichoccursduringtheexecutionofaprogram,thatdisruptsthenormalflowoftheprogram.Ingeneral,whenaPythonscriptencountersasituationthatitcan’tcopewith,itraisesanexception.AnexceptionisaPythonobjectthatrepresentsanerror.

Someunexpectedcondition(s)thatarenotpartofnormaloperationsplannedduringcodingare:

OutofMemoryInvalidfilenameAttemptingtowriteintoreadonlyfileGettinganincorrectinputfromuserDivisionbyzeroAccessinganoutofboundlistelementTryingtoreadbeyondendoffileSendingillegalargumentstoamethod

Ifanyofsuchsituationsisencountered,agoodprogramwilleitherhavethecodecheckforthemandperformsomesuitableactiontoremedythem,oratleaststopprocessinginawelldefinedwayaftergivingappropriatemessage(s).Sowhatwearesayingisifanerrorhappened,theremustbecodewritteninprogram,torecoverfromtheerror.Incaseifitisnotpossibletohandletheerrorthenitmustbereportedinuserfriendlywaytotheuser.

ExceptionhandlingExceptionshandlingistheprocessofrespondinginsuchsituations.Mostofthe

modernprogramminglanguagesprovidesupportwithhandlingexceptions.Theyofferadedicatedexceptionhandlingmechanism,whichsimplifiesthewayinwhichanexceptionsituationisreportedandhandled.

Forhandlingexceptionalsituationspythonprovides

1.raisestatementtoraiseexceptioninprogram

2.try…..exceptstatementforcatchingandhandlingtheerrors.

WhenaPythonscriptraisesanexception,itmusteitherhandletheexceptionimmediatelyotherwiseitwouldterminateandcomeout.Ifwehavesomesuspiciouscodethatmayraiseanexception,wecandefendourprogrambyplacingthesuspiciouscodeinatry:block.Afterthetry:block,includeanexcept:statement,followedbyablockofcodewhichhandlestheproblemaselegantlyaspossible.

Syntax:

………………….

exceptExceptionA:

exceptExceptionB:

………………….

Noexception

Asingletrystatementcanhavemultipleexceptstatements.Wecanalsoprovideagenericexceptclause,whichhandlesanyexception.Aftertheexceptclause(s),wecanincludeanelse-clause.Thecodeintheelse-blockexecutesifthecodeinthetry:blockdoesnotraiseanexception.

n=input(“Enteryear”)

ifn<1000orn>2015:

raise“Invalidyear”,n

month=input(“Entermonth”)

ifmonth<1ormonth>12:

raise“Invalidmonth”,month

day=input(“Enterday”)

ifday<1orday>31:

raise“Invalidday”,day

printday,‘/’,month,‘/’,n

except:

print“WrongValues”

Wecanalsousethesameexceptstatementtohandlemultipleexceptionsasfollows.

………………….

except(Exception1[,Exception2[,…ExceptionN]]]):

………………….

noexception

Thefinallyblockisaplacetoputanycodethatmustexecute,whetherthetry-blockraisedanexceptionornot.Thesyntaxofthetry-finallystatementis:

………………….

finally:

………………….

Whenanexceptionisthrowninthetryblock,theexecutionimmediatelypassestothefinallyblock.Afterallthestatementsinthefinallyblockareexecuted,theexceptionisraisedagainandishandledintheexceptstatementsifpresentinthenexthigherlayerofthetry-exceptstatement.

Anexceptioncanhaveanargument,whichisavaluethatgivesadditionalinformationabouttheproblem.Thecontentsoftheargumentvarybyexception.

………………….

exceptExceptionType,Argument:

Wecanraiseexceptionsinseveralwaysbyusingtheraisestatement.Thegeneralsyntaxfortheraisestatement.

raise[Exception[,args[,traceback]]]

Here,Exceptionisthetypeofexception(forexample,NameError)andargumentisavaluefortheexceptionargument.Theargumentisoptional;ifnotsupplied,theexceptionargumentisNone.

Thefinalargument,traceback,isalsooptional(andrarelyusedinpractice),andifpresent,isthetracebackobjectusedfortheexception.

User-DefinedExceptions

Pythonalsoallowsustocreateourownexceptionsbyderivingclassesfromthestandardbuilt-inexceptions.Forexample,let’stakeaclassthatissubclassedfromRuntimeError.Thisisusefulwhenyouneedtodisplaymorespecificinformationwhenanexceptioniscaught.

Araisestatementthatdoesnotincludeanexceptionnamewillsimplyraisethecurrent

exception.Hereexceptionnameisthetypeoferror,whichcanbestring,classorobjectandargumentisthevalue.AsargumentisoptionalitsdefaultvalueNoneisusedincasetheargumentisnotprovided.

S.No ErrorType Description

1 IOError I/Ooperationfails

2 EOFError Afilemethodtriestoreadbeyondthefile.

3 ZeroDivisionError Denominatorindivisioniszero.

4 NameError Variable/functionnameisnotfound

5 IndexError Index/Subscriptisoutofrange

6 ImportError Importstatementfailstofindthemoduledefinitionorfilename

7 IndentationError Incorrectindentation

8 TypeError Performanoperationonincorrecttypeofvalue

9 ValueError Built-infunctionreceivesanargumentofcorrecttypebutincorrectvalue

Table12.1:Typesofexceptions

Example:

>>>l=[11,22,33]

>>>i=input(“Enterindex”)

>>>ifi>len(l):

raiseIndexError

printl[i]

Ifindexvalueis5,thecodewillraiseanerror,duringexecution.Theerrorwillbeindexerrorasmentionedinraisestatement.

>>>defmenu(choice):

ifchoice<1:

raise“invalidchoice”,choice

Inordertohandletheerrorsraisedbythestatement,wecanusetryexceptstatement.

try…..exceptisusedwhenwethinkthatthecodemightfail.Ifthishappensthenweareabletocatchitandhandlesameinproperfashion.Let’sre-considerthemenu()functiondefinedabovetohandletheerroralso:

whileTrue:

x=int(raw_input(“Enteranumber”))

exceptValueError:

print”Thiswasnotavalidnumber.Enteravalidnumber”

Thiscodewillaskusertoinputavalueuntilavalidintegervalueisentered.

Oncewhileloopisenteredexecutionoftryclausebegins,ifnoerrorisencountered,i.e.thevalueenteredisinteger,exceptclausewillbeskippedandexecutionoftryfinishes.Ifanexceptionoccursi.e.anintegervalueisnotenteredthenrestoftryclauseisskippedandexceptcauseisexecuted.

Let’stakeanexampleofexceptionhandlingindatafile.

f=open(“testfile”,“w”)

f.write(“Thisismytestfileforexceptionhandling!!”)

exceptIOError:

print“Error:can'tfindfileorreaddata”

print“Writtensuccessfully”

Thiswillproducethefollowingresult,ifyouarenotallowedtowriteinthefile:

Error:can’tfindfileorreaddata

Generatorfunctions

Whenanormalpythonfunctioniscalled,inaprogram,thecontrolfromcallingfunctionisshiftedtocalledfunction.Executionofcalledfunctionstartsfromfirstlineandcontinuesuntilareturnstatementorexceptionorendoffunctionisencountered.Inallthesesituations,thecontrolisreturnedbacktocallerfunction.Thatmeansanyworkdonebythecalledfunctionforprovidingtheresultislost.Touseitagainwewillagaincallthefunctionanditsexecutionwillstartfromscratch.

Sometimesinprogrammingweneedtohavefunctionswhichareabletosaveitswork,sothatinsteadofstartingfromscratchthefunctionstartsworkingfromthepointwhereitwasleftlast.Inotherwords,afunctionshouldbeabletoyieldaseriesofvaluesinsteadofjustreturningasinglevalue.Herereturningavaluealsoimpliesreturningofcontrol.

SuchfunctionsareGeneratorfunctions.Thesefunctionscansendbackavalueandlaterresumeprocessingfromtheplace,wheretheyleftoff.Thisallowsthefunctiontoproduceaseriesofvalues-overtime,ratherthancomputingthemallatonceandreturningalistofvalues.

Generatorfunctionsarenotmuchdifferentfromnormalfunctions,theyalsousedeftodefineafunction.Theprimarydifferencebetweengeneratorandnormalfunctionisthatgeneratorwillyieldavalueinsteadofreturningavalue.

The yield suspends the function and sends a value back to the caller while retainsenoughstatetoenablethefunctionimmediatelyafterthelast yield run.Thisallowsthegeneratorfunctiontoproduceaseriesofvaluesovertimeratherthancomputingthemallatonceandsendingthembackinalist.

Let’sgeneratethecubesofnumbers.

Example12.1:Generatingcubeofnumbers

>>>defcube_generator(n):

foriinrange(n):

yieldi**3

it’s used in a for loop, control returns to the function afteritsyieldstatementeachtimethroughtheloop:

>>>foriincube_generator(5):

printi,#Python2.x

Output:

0:1:8:27:64:

Ifweusereturninsteadofyield,theresultis:

>>>defcube_generator(n):

foriinrange(n):

returni**3

Traceback(mostrecentcalllast):

File””,line1,in

foriincubic_generator(5):

TypeError:‘int’objectisnotiterable

The function yields a value and so returns to its caller each time through the loop.When it is resumed, its prior state is restored and control picks up again aftertheyieldstatement.When

Example12.2:Fibonacciseries

deffibonacci(max):

a,b=0,1#1

whilea<max:

yielda#2

a,b=b,a+b#3

Let’srunthroughthiscode.

1. It startswith0 and 1, goes up slowly at first, then more and morerapidly. To start the sequence, we need two variables: a starts at 0,andbstartsat1.

2. aisthecurrentnumberinthesequence,soyieldit.3. b is the next number in the sequence, so assign that to a, but also

calculatethenextvaluea+bandassignthattobforlateruse.Notethat thishappens inparallel; ifa is3andb is5, thena,b=b, a+bwillsetato5(thepreviousvalueofb)andbto8(thesumofthepreviousvaluesofaandb).

Wecanuse a generator like fibonacci() in a for loopdirectly.The forloop will automatically call the next() function to get values fromthefibonacci()generatorandassignthemtotheforloopindexvariable(n).Eachtimethroughtheforloop,ngetsanewvaluefromtheyieldstatementinfibonacci(),andallwehave todo isprint itout.Once fibonacci() runsoutofnumbers(abecomesbiggerthanmax,whichinthiscaseis500),thentheforloopexitsgracefully.

Generatorscanbebetterintermsofmemoryusageandtheperformance.Theyallowfunctionstoavoiddoingalltheworkupfront.Thisisespeciallyusefulwhentheresultinglistsarehugeorwhenitconsumesalotofcomputationtoproduceeachvalue.Generatordistributes the time required to produce the series of values among loop iterations.Generators can provide simpler alternatives to manually saving the state betweeniterationsinclassobjects.

SolvedExamples1. Whatisexceptionhandling?

Ans.Errorsareexceptional,unusualandunexpectedsituationsandtheyareneverpartofthenormalflowofaprogram.Ifanerrorhappened,theremustbecodewritteninprogram,torecoverfromtheerror.Incaseifitisnotpossibletohandletheerrorthenitmustbereportedinuserfriendlywaytotheuser.

2.Whendowegettypeerror?

Ans.Whenwedonotgiveanumberforindex,

num=[‘Red’,‘Blue’,‘Green’]

printnum[‘Red’]

exceptTypeError:

print‘Enteronlynumberforindex’

3.Whataregeneratorfunctions?

Ans.Generatorfunctionscansendbackavalueandlaterresumeprocessingfromtheplace,wheretheyleftoff.Thisallowsthefunctiontoproduceaseriesofvalues-overtime,ratherthancomputingthemallatonceandreturningalistofvalues.

Generatorfunctionsarenotmuchdifferentfromnormalfunctions,theyalsousedeftodefineafunction.Theprimarydifferencebetweengeneratorandnormalfunctionisthatgeneratorwillyieldavalueinsteadofreturningavalue.

Itistheyieldstatementwhichallowsthegeneratorfunctiontosuspendtheprocessingandsendavalue,simultaneouslyretainingtheexistingstateofgeneratortoresumeprocessingovertime.

4.Writeacodesnippettogeneratesquaresusinggeneratorfunctions.

#Squaresusinggenerator

defSquare(n):

foriinrange(n):

yieldi**2

forkinSquare(6):

printk,

5.Howisyielddifferentfromreturn?

Ans.Yieldisakeywordthatisusedlikereturn,exceptthefunctionwillreturnagenerator.

6.Whatistheuseofraisestatement?Mentionitssyntax.

Ans.Raisestatementallowstheprogrammertoforceaspecifiedexceptiontooccur.Onceanexceptionisraised,it’suptocallerfunctiontoeitherhandleitusingtry/exceptstatementorletitpropagatefurther.

Syntaxofraiseis:

raise[exceptionname[,argument]]

7. Findoutthesituation(s)inwhichfollowingcodemaycrash.

whileloop==1:

a=input(‘Enteranumbertosubtractfrom>‘)

b=input(‘Enterthenumbertosubtract>‘)

exceptNameError:

print“\nYoucannotsubtractaletter”

continue

exceptSyntaxError:

print“\nPleaseenteranumberonly.”

continue

printa-b

loop=input(‘Press1totryagain>‘)

except(NameError,SyntaxError):

loop=0

Thecodemightnotcrashasallexceptionshavebeentakencareof.

8.WriteafunctioncalledoopsthatexplicitlyraisesaIndexErrorexceptionwhencalled.Thenwriteanotherfunctionthatcallsoopsinsideatry/exceptstatementtocatchtheerror.WhathappensifyouchangeoopstoraiseKeyErrorinsteadofIndexError?

defoops():

l=[1,2,3]

ifi>len(l):

raiseIndexError

printl[i]

defhandled():

oops()

except(IndexError):

print“Youaretryingtoaccessthelistwithaninvalidindex”

handled()

Output:

Youaretryingtoaccessthelistwithaninvalidindex

WhenweraiseKeyError,anexceptionisthrownonthescreen.

9.Writeafunctiontofindaverageofalistofnumbers.Yourfunctionshouldbeabletohandleanemptylistandalsolistcontainingstring.

n=input(“Enternumberofnumbers”)

foriinrange(n):

l.append(input(“Enternumber”))

foriinrange(len(l)):

sum=sum+l[i]

avg=sum/len(l)

print“Average=”,avg

exceptNameError:

print“Enteronlynumber”

exceptTypeError:

print“WrongType”

PracticeQuestions

1.Findoutthesituation(s)inwhichfollowingcodemaycrash

whileloop==1:

a=input(‘Enteranumbertosquare>‘)

exceptNameError:

print“\nYoucannotsquareacharacter”

continue

exceptSyntaxError:

print“\nPleaseenteranumberonly.”

continue

printa*a

loop=input(‘Press1totryagain>‘)

except(NameError,SyntaxError):

loop=0

2.Whatisthepurposeofyieldstatement?

3.WhataretheapplicationsofGeneratorfunctions?

4.Writeafunctiontosearchalistofnumbers.Yourfunctionshouldbeabletohandleastringinput.

5.Writeaprogram,toacceptadateasday,month&yearfromuserandraiseappropriateerror(s),iflegalvalue(s)isnotsupplied.Displayappropriatemessagetilluserinputscorrectvalue(s).

6.Createaclassstudenttostorestudentdata.Ensurethatwhileacceptingthedataincorrectentryisproperlyhandled.

Chapter13:SampleApplications

Project1:Inventorymanagement

Createaclassitemtostoreinformationofdifferentitems,existinginashop.Atleastfollowingistobestoredw.r.t.eachitemcode,name,price,qty.Writeaprogramtoacceptthedatafromuserandstoreitpermanentlyinthefile.

Program:

importpickle

importos

importsys

classITEM:

def__init__(self):

self.itemcode=0

self.itemname=”

self.price=0.0

self.qty=0

defget(self):

self.itemcode=input(“Enteritemcode”)

self.itemname=raw_input(“Enteritemname”)

self.price=float(raw_input(“Enterprice”))

self.qty=input(“Enterquantity”)

pickle.dump(self,open(“save.txt”,“wb”))

print“SuccessfullySaved”

defdisplay(self):

print“Readingfromthefile”

self=pickle.load(open(“save.txt”,“rb”))

print“ItemCode”,self.itemcode

print“ItemName”,self.itemname

print“Price”,self.price

print“Quantity”,self.qty

x=ITEM()

x.get()

x.display()

Outputscreenshot:

Project2:Quiz

Thequizprojecthasanadministratorwhocancreateaquizandviewallquestions.Anyotheruserisgivenasetofsay20questionsonebyoneandtheirscoreiscalculatedforeachcorrectanswer.Attheendofthequiz,theirscoresaredisplayed.

#Quizclasscontainsthequestionsandthecorrectanswers

filename=“Quiz.txt”

ans={}

#Getinformationfromfiles

importos

ifos.path.exists(filename):

store=open(filename,‘r’)

forlineinstore:

term=line.rstrip()

answer=store.next().rstrip()

ans[term]=answer

store.close()

cont=0

whilech==0:

choice=int(raw_input(“MENU1-CREATE2-PLAY3-QUIT”))

ifchoice==1:

whilecont==0:

term=raw_input(“Enterquestion:”)

term=term.rstrip()

whiletermnotinans:

answer=raw_input(“Enteranswer”)

ans[term]=answer

store=open(filename,‘w’)

forterm,answerinans.items():

store.write(str(term)+‘\n’)

store.write(answer+‘\n’)

store.close()

cont=int(raw_input(“Aretheremorequestions0tocontinue”))

elifchoice==2:

print“WelcometoQuiz”

score=0

forques,answerinans.items():

printstr(ques)

correct=ans.get(ques)

userans=raw_input(“Ans:”)

ifuserans==correct:

score=score+1

print“Youscored“,score,“outof”,len(ans)

print“ThankYou”

ch=int(raw_input(“Doyouwishtocontinue..press0”))

Project3:Databasesoperationsusingpython

ProblemDescription

Writeasimplepythonprogramtoconnecttoadatabaseandperformdatabaseoperations.

Technicaldocumentation:

Gotohttps://code.google.com/p/pyodbc/downloads/list

Downloadtherequiredversion

Startbyimportingthepyodbcmodule

importpyodbc

Connections

TheConnectionobjectrepresentsasingleconnectiontothedatabaseandisobtainedfromthemodule’sconnectfunction:

cnxn=pyodbc.connect(‘DRIVER={SQLServer};SERVER=localhost;DATABASE=mine;UID=me;PWD=pwd’)

Therearetwoprimaryfeaturesoftheconnectionobject:

1. Youusecnxn.cursor()tocreateanewCursor.

2. Youusecnxn.commit()orcnxn.rollback()tocommitorrollbackworkperformedwiththeCursor.

commit

Weneedtoenableautocommit(inthepyodbc.connectfunctionorwithConnection.autocommit),alluncommitedworkwillbediscardedwhentheConnectionobjectisclosed.Wemustcallcnxn.commit()

cnxn=pyodbc.connect(…)#doworkhere…cnxn.commit()cnxn.close()

Cursors

CursorobjectsareusedtoexecuteSQL.

Program

importpyodbc

#ConnectionstringServername,databasename,userid=saandpassword

con=pyodbc.connect(‘DRIVER={SQLServer};SERVER=WIN-URCSEH98ZFA;DATABASE=record;UID=sa;PWD=password12%’)

#createacursorforthisconnection

cur=con.cursor()

whileTrue:

choice=input(“1-VIEW2-INSERT3-DELETE4-UPDATE5-SEARCH6-EXIT”)

ifchoice==1:

Select_Command=(“SELECT*fromstudent”)

cur.execute(Select_Command)

results=cur.fetchall()

print“RollNoNameGrade”

forrinresults:

print(str(r[0])+”“+r[1]+r[2])

elifchoice==2:

roll=input(“Entertherollnumbertobeinserted”)

sname=raw_input(“Enterthenametobeinserted”)

grade=raw_input(“Enterthegradetobeinserted”)

insert_command=(“insertintostudent(RollNo,Name,Grade)VALUES(?,?,?)”)

cur.execute(insert_command,roll,sname,grade)

con.commit()

elifchoice==3:

roll=input(“Entertherollnumbertobedeleted”)

delete_command=(“deletefromstudentwhererollno=?”)

cur.execute(delete_command,roll)

con.commit()

except:

print(“Errorindelete”)

elifchoice==4:

roll=input(“Entertherollnumbertobeupdated”)

newgrade=raw_input(“Enterthenewgrade”)

update_command=(“updatestudentsetgrade=?whererollno=?”)

cur.execute(update_command,newgrade,roll)

con.commit()

except:

print(“Errorinupdate”)

elifchoice==5:

roll=input(“Entertherollnumbertobesearched”)

search_command=(“SELECT*fromstudentwhererollno=?”)

cur.execute(Select_Command,roll)

results=cur.fetchone()

print(str(r[0])+”“+r[1]+r[2])

print“Done”

con.close()

Outputscreenshot:

Project4:CALCULATOR

ThisprojectaimstocreateasimplecalculatorusingclassesandGUI.

SourceCode:

#calc.py-aPythoncalculator

fromTkinterimport*

importmath

#themainclass

classCalc():

def__init__(self):

self.total=0

self.current=””

self.new_num=True

self.op_pending=False

self.op=””

self.eq=False

defnum_press(self,num):

self.eq=False

temp=text_box.get()

temp2=str(num)

ifself.new_num:

self.current=temp2

self.new_num=False

iftemp2==‘.’:

iftemp2intemp:

return

self.current=temp+temp2

self.display(self.current)

defcalc_total(self):

self.eq=True

self.current=float(self.current)

ifself.op_pending==True:

self.do_sum()

self.total=float(text_box.get())

defdisplay(self,value):

text_box.delete(0,END)

text_box.insert(0,value)

defdo_sum(self):

ifself.op==“add”:

self.total+=self.current

ifself.op==“minus”:

self.total-=self.current

ifself.op==“times”:

self.total*=self.current

ifself.op==“divide”:

self.total/=self.current

ifself.op==‘square’:

self.total=math.pow(self.total,self.current)

self.new_num=True

self.op_pending=False

self.display(self.total)

defoperation(self,op):

self.current=float(self.current)

ifself.op_pending:

self.do_sum()

elifnotself.eq:

self.total=self.current

self.new_num=True

self.op_pending=True

self.op=op

self.eq=False

defcancel(self):

self.eq=False

self.current=“0”

self.display(0)

self.new_num=True

defall_cancel(self):

self.cancel()

self.total=0

defsign(self):

self.eq=False

self.current=-(float(text_box.get()))

self.display(self.current)

sum1=Calc()

root=Tk()

cal=Frame(root)

cal.grid()

root.title(“Calculator”)

text_box=Entry(cal,justify=RIGHT)

text_box.grid(row=0,column=0,columnspan=3,pady=5)

text_box.insert(0,“0”)

#makethebuttons

numbers=“123456789”

bttn=[]

forjinrange(1,4):

forkinrange(3):

bttn.append(Button(cal,text=numbers[i],bg=‘black’,fg=‘white’,font=‘bold’))

bttn[i].grid(row=j,column=k,pady=5)

bttn[i][“command”]=lambdax=numbers[i]:sum1.num_press(x)

zero=Button(cal,text=‘0’,bg=‘black’,fg=‘white’,font=‘bold’)

zero[‘command’]=lambda:sum1.num_press(0)

zero.grid(row=4,column=1,pady=5)

multiply=Button(cal,text=‘X’,bg=‘green’,fg=‘black’,font=‘bold’)

multiply[‘command’]=lambda:sum1.operation(‘times’)

multiply.grid(row=2,column=3,pady=5)

minus=Button(cal,text=‘-‘,bg=‘green’,fg=‘black’,font=‘bold’)

minus[‘command’]=lambda:sum1.operation(‘minus’)

minus.grid(row=3,column=3,pady=5)

point=Button(cal,text=‘.’,bg=‘black’,fg=‘white’,font=‘bold’)

point[‘command’]=lambda:sum1.num_press(‘.’)

point.grid(row=4,column=0,pady=5)

add=Button(cal,text=‘+’,bg=‘green’,fg=‘black’,font=‘bold’)

add[‘command’]=lambda:sum1.operation(‘add’)

add.grid(row=4,column=3,pady=5)

neg=Button(cal,text=‘+/-‘,bg=‘blue’,fg=‘black’,font=‘bold’)

neg[‘command’]=sum1.sign

neg.grid(row=5,column=0,pady=5)

cancel=Button(cal,text=‘C’,bg=‘red’,fg=‘black’,font=‘bold’)

cancel[‘command’]=sum1.cancel

cancel.grid(row=5,column=1,pady=5)

clear_all=Button(cal,text=‘AC’,bg=‘red’,fg=‘black’,bd=10)

clear_all[‘command’]=sum1.all_cancel

clear_all.grid(row=1,column=3,pady=5)

equals=Button(cal,text=‘=’,bg=‘orange’,fg=‘black’,font=‘bold’)

equals[‘command’]=sum1.calc_total

equals.grid(row=4,column=2,pady=5)

divide=Button(cal,text=‘/’,bg=‘green’,fg=‘black’,font=‘bold’)

divide[‘command’]=lambda:sum1.operation(‘divide’)

divide.grid(row=5,column=3,pady=5)

square=Button(cal,text=‘^’,bg=‘blue’,fg=‘white’,font=‘bold’)

square[‘command’]=lambda:sum1.operation(‘square’)

square.grid(row=5,column=2,pady=5)

root.mainloop()

SourceCode:Calculatorproject

Fig:Calculatorprojectscreenshots

Solutionstopracticequestions(selected)

Chapter2

1.name1=raw_input(“Firstperson-enteryourname”)

name2=raw_input(“Secondperson-enteryourname”)

print“Hello”,name1

print“Hello”,name2

3.a)45

Chapter31. defSubtractNumber(x,y):

result=x-y

returnresult

#Get2numbers

num1=input(“Enterfirstnumber”)

num2=input(“Entersecondnumber”)

res=SubtractNumber(num1,num2)

print“Subtractionresult”,num1,”-“,num2,”=”,res

2.defpower(x,y=2):

foriinrange(1,y+1):

sum=sum*x

returnsum

print“Usingdefaultargument”

num=input(“Enterthebase”)

printpower(num)

print“Valueprovidedforbotharguments”

exp=input(“Enterexponent”)

printpower(num,exp)

Chapter4

importmath

importcmath

print“\nEnterthevaluesfora,bandc.”

a=float(raw_input(“a?”))

b=float(raw_input(“b?”))

c=float(raw_input(“c?”))

ifb*b-4*a*c<0:

print“Thisquadratichasimaginaryroots.”

root=(-b-cmath.sqrt(b*b-4*a*c))/(2*a)

print“x=”,root

root=(-b+cmath.sqrt(b*b-4*a*c))/(2*a)

print“x=”,root

elifb*b-4*a*c==0:

print“Thisquadraticequationhasequalroots.”

root=-b/(2*a)

print“x=”,root

print“Thisquadratichasrealanddistinctroots.”

root=(-b-math.sqrt(b*b-4*a*c))/(2*a)

print“x=”,root

root=(-b+math.sqrt(b*b-4*a*c))/(2*a)

print“x=”,root

raw_input()

importmath

print“\nEntercustomer’sname”

name=raw_input(“name?”)

print“\nEnterthepreviousmonth’sreading.”

prev=float(raw_input(“prev?”))

print“\nEnterthecurrentmonth’sreading.”

curr=float(raw_input(“curr?”))

units=curr-prev

ifunits<=100:

bill=units*4.00;

elifunits>100andunits<500:

bill=400+(units-100)*5.00;

bill=400+2000+(units-500)*6.00;

print“No.ofunitsconsumed=“,units

print“Amountpayabletotheelectricitydepartment=Rs”,bill

raw_input()

importmath

sign=1

n=int(raw_input(“Enterthevalueofn:”))

x=int(raw_input(“Enterthevalueofx:”))

whilei<n:

whilej<i:

sum=sum+sign*(pow(x,i)/f)

sign=-sign;

print”1-x/1!+x^2/2!-x^3/3!+…+(-1)^nx^n/n!=”,sum

raw_input()

Chapter5

1.#Countingvowels

count=0;

line=raw_input(“Enteraword:”)

foriinrange(0,len(line)):

line=line.lower()

if((line[i]==‘a’)or(line[i]==‘e’)or(line[i]==‘i’)or(line[i]==‘o’)or(line[i]==‘u’)):

count=count+1

print“\nNoofvowels=“,count

raw_input()

importre

value=[]

print””””Rules:Atleast1uppercaseletter,1lowercaseletter,

1specialcharacterand1numbermin6charactermax20characters””””

items=[xforxinraw_input(“Enterthepasswordlist”).split(‘,’)]

forpinitems:

p=p.strip()

iflen(p)<6orlen(p)>20:

print“Lengtherror”,p

continue

ifnotre.search(“[a-z]”,p):

continue

elifnotre.search(“[0-9]”,p):

continue

elifnotre.search(“[A-Z]”,p):

continue

elifnotre.search(“[?$#@!*]”,p):

continue

elifre.search(“\s”,p):

continue

value.append(p)

print“Thevalidpasswordlistis”

print“,”.join(value)

#Getnamesfromtheuser

names=list()

n=int(raw_input(“Enterthenumberofnames:-”))

print“Enterthenames”;

foriinrange(0,n):

names.append(raw_input())

foriinrange(0,n):

forjinrange(i,n):

ifnames[i]>names[j]:

temp=names[i]

names[i]=names[j]

names[j]=temp

print“SortedArray:\n”

foriinrange(n):

printnames[i]

raw_input()

Chapter61.defsumodd(L):

whilepos<len(L):

ifL[pos]%2==1:

sum=sum+L[pos]

pos=pos+1

printsum

2. importrandom

print”TocreateamatrixoftheformM*M”

m=input(“Enterthenumberofrows:-“)

n=input(“Enterthenumberofcolumns:-“)

a=[[random.randint(1,9)forrowinrange(n)]forcolinrange(m)]

foriinrange(m):

forjinrange(n):

printa[i][j],

print”__________ToPrintTheRowSum______________”

foriinrange(m):

forjinrange(n):

sum=sum+a[i][j]

printsum,

print”___________ToPrintTheColumnSum____________”

foriinrange(n):

forjinrange(m):

sum=sum+a[j][i]

printsum

print”_______________LEFTDIAGONALSUM______________”

foriinrange(m):

forjinrange(n):

ifi==j:

sum=sum+a[i][i]

printsum

print”_____________RIGHTDIAGONALSUM______________”

foriinrange(m):

forjinrange(n):

ifi+j==m-1:

sum=sum+a[i][j]

printsum,

3.defoverlapping(a,b):

l1=len(a)

l2=len(b)

foriinrange(l1):

forjinrange(l2):

ifa[i]==b[j]:returnTrue

else:returnFalse

6.defduplicates():

a=[1,2,3,2,1,5,6,5,5,5]

forelemina:

ifelemind:d[elem]+=1else:d[elem]=1

printelem

print[xforx,yind.items()ify>1],print“haveduplicates”

printd

Chapter7

1.city=dict()

whilei<=n:

a=raw_input(“entercityname”)

b=raw_input(“enterpopulation”)

city[a]=b

printcity

2.defprint_menu():

print(‘1.AddaPhoneNumber’)

print(‘2.RemoveaPhoneNumber’)

print(‘3.SearchaPhoneNumber’)

print(‘4.ModifyaPhoneNumber’)

print(‘5.Displaythephonebook’)

print(‘6.Quit’)

phonebook={}

menu_choice=0

print_menu()

whilemenu_choice!=6:

menu_choice=int(raw_input(”Enterchoice(1-5):“))

ifmenu_choice==1:

print(“Insertion”)

phone=raw_input(“Number:“)

phonebook[name]=phone

elifmenu_choice==2:

print(”Deletion”)

ifnameinphonebook:

delphonebook[name]

elifmenu_choice==3:

print(“Searching”)

ifnameinphonebook:

print(“Thenumberis”,phonebook[name])

elifmenu_choice==4:

print(“Update”)

ifnameinphonebook:

newno=raw_input(“Enternewtelephonenumber”)

phonebook[name]=newno

elifmenu_choice==5:

print(“Phonebook:”)

forxinphonebook.keys():

print(x,phonebook[x])

print“Thankyou”

customer=dict()

n=input(”Entertotalnumberofcustomers”)

whilei<=n:

a=raw_input(“entercustomername”)

b=raw_input(“entercustomernumber”)

customer[a]=b

name=raw_input(“entercustomernametodelete”)

delcustomer[name]

l=customer.keys()

print“CustomerInformation”

print“Name”,‘\t’,“number”

foriinl:

printi,‘\t’,customer[i]

Chapter81. t=tuple()

n=input(“Entertotalnumberofemployees”)

foriinrange(n):

a=input(“entersalaryofemployee:”)

t=t+(a,)

print“maximumsalary=”,max(t)

print“minimumsalary=”,min(t)

Chapter10

classitems:

def__init__(self,s=None):

ifs==None:

self.itemname=”

self.itemcode=0

self.itemprice=0.0

self.itemqty=0

self.itemname=s.itemname

self.itemcode=s.itemcode

self.itemprice=s.itemprice

self.itemqty=s.itemqty

defget(self):

print”

self.itemname=raw_input(‘Enternameofitem:‘)

self.itemcode=input(‘Enteritemcode:‘)

self.itemprice=float(raw_input(‘Enteritemprice:‘))

self.itemqty=input(‘Enterquantity:‘)

print”

defshow(self):

printself.itemname,‘\t\t’,self.itemcode,‘\t\t’,self.itemprice,‘\t\t’,self.itemqty

s=items()

inventorylist=[]

n=input(‘Enternumberofitems:‘)

foriinrange(n):

s.get()

inventorylist.append(items(s))

print“ITEMSSORTEDBYPRICE”

foriinrange(len(inventorylist)):

forjinrange(i+1,len(inventorylist)):

ifinventorylist[i].itemprice>inventorylist[j].itemprice:

inventorylist[i],inventorylist[j]=inventorylist[j],inventorylist[i]

print‘ITEM\t\tCODE\t\tPRICE\t\tQUANTIY’

foritemininventorylist:

item.show()

raw_input()

definsertionsort(a):

foriinrange(1,len(a)):

currentval=a[i]

whilepos>0anda[pos-1]>currentval:

a[pos]=a[pos-1]

pos=pos-1

a[pos]=currentval

print“Yoursortedlistis”,a

n=input(“Enternumberofintegers:-”)

foriinrange(n):

a.append(input(“Enternumbers:-”))

print“Yourlistis”,a

insertionsort(a)

6.classstack:

defpush(self):

a=input(“Enternumber:”)

stack.s.append(a)

defpop(self):

if(a.s==[]):

print“StackEmpty”

print“Deletedelementis:“,a.s.pop()

defdisplay(self):

l=len(stack.s)

printstack.s[i]

a=stack()

n=input(“Entercountofnumbers”)

foriinrange(n):

a.push()

a.pop()

a.display()

7.#Bookstack

classstack:

count=0

defpush(self):

no=input(“Enterbooknumber”)

name=raw_input(“Enteranyname:”)

stack.book=name

stack.s.append(stack.book)

stack.count=stack.count+1

defpop(self):

stack.count=stack.count-1

printstack.s.pop()

printstack.count

#print“Deletedelementis:“,stack.s[stack.count].pop()

defdisplay(self):

l=len(stack.s)

print“BOOKNUM”,““,“BOOKNAME”

printi+1,““,stack.s[i]

a=stack()

choice=0

whilechoice<4:

choice=int(raw_input(“Enter1-push2-pop3-view4-quit”))

ifchoice==1:

foriinrange(n):

a.push()

elifchoice==2:

a.pop()

elifchoice==3:

a.display()

8.classReservationQ:

def__init__(self):

self.items=[]

defisEmpty(self):

returnself.items==[]

defenqueue(self,item):

self.items.insert(0,item)

defdequeue(self):

returnself.items.pop()

defsize(self):

returnlen(self.items)

defdisplay(self):

print“FRONT—>”,

x=self.size()

forainrange(x-1,-1,-1):

printself.items[a],“—>”,

print“REAR”

choice=0

x=ReservationQ()

whilechoice<4:

choice=input(“Enter1-insert2-delete3-view4-quit”)

ifchoice==1:

ifx.size()>4:

print”Reservationisnotpossible”

item=raw_input(“EnterPNRnumber”)

x.enqueue(item)

elifchoice==2:

ifx.isEmpty():

print“ReservationQueueisempty”

x.dequeue()

elifchoice==3:

x.display()

Chapter11

1.defCountDorM():

count=0

withopen(‘DELHI.txt’,‘r’)asf:

whileTrue:

line=f.readline()

ifnotline:break

ifline[0]==‘D’orline[0]==‘M’:

count=count+1

ifcount==0:

print“nolinestartswithDorM”

CountDorM()

2.defcountchar():

fname=“story.txt”

count=0

c=raw_input(“Enterthecharactertosearchfor”)

withopen(fname,‘r’)asf:

forlineinf:

forwordinline:

forcharinword:

ifchar.strip()==c.strip():

count=count+1

print“No.ofoccurencesof”,c,“=”,count

countchar()

3.Ans.

importpickle

#Creatingthedictionary

R={‘I’:1,‘II’:2,‘III’:3,‘IV’:4,‘V’:5}

file=open(‘myfile.dat’,‘wb’)

pickle.dump(R,file)

file.close()

roman=raw_input(“Entertheromannumeral”)

#readpythondictbackfromthefile

ifile=open(‘myfile.dat’,‘rb’)

R=pickle.load(ifile)#readingdatafrombinaryfile

print“DecimalEquivalentof”,roman,“is”,R[roman]

except:

print“Noequivalentfound”

forlineinopen(“story.txt”):

line=line.strip()

ifline[0]==‘#’:

printline

except:

print‘FileNotFound’

Chapter12

n=input(“Enteryear”)

ifn<1000orn>2015:

raise“Invalidyear”,n

month=input(“Entermonth”)

ifmonth<1ormonth>12:

raise“Invalidmonth”,month

day=input(“Enterday”)

ifday<1orday>31:

raise“Invalidday”,day

printday,‘/’,month,‘/’,n

except:

print“WrongValues”

6.classStudent:

def__init__(self):

self.rollno=0

self.name=”

self.marks=[0,0,0]

self.grade=”

defread(self):

#Thisfunctiongetsthedetailsofastudentfromtheuser

whilex==1:

self.rollno=input(“Enterrollnumber:-”)

exceptNameError:

print“Rollnumbershouldbeanumber”

continue

self.name=raw_input(“Entername:-”)

self.marks=float(raw_input(“Enterthemarks-”))

exceptNameError:

print“Marksshouldbedecimal”

continue

exceptValueError:

print“Marksshouldbedecimal”

continue

s=Student()

s.read()

Referencebooks1.“PythonProgrammingfortheAbsoluteBeginner”byMichaelDawsonPremierPress2003.2.PythonTutorialRelease2.6.3byGuidovanRossumandFredL.Drake,Jr.,editorOctober06,2009-PythonSoftwareFoundation3.“ComputerScience–ClassXI”byCentralBoardofSecondaryEducation,NewDelhi2013.4.“IntroductiontoProgrammingUsingPython”byBrianHeinold,DepartmentofMathematicsandComputerScience,MountSt.Mary’sUniversity5.“COMPREHENSIVECOMPUTERSCIENCEWITHPYTHON–XI”byPavithraKarthik,LaxmiPublications,20156.“COMPREHENSIVECOMPUTERSCIENCEWITHPYTHON–XII”byPavithraKarthik,LaxmiPublications,2016

Weblinks1. http://www.tutorialspoint.com/python2. http://docs.python.org/3. http://www.pythontutor.com/4. www.studiestoday.com

Otherbooksbythesameauthor1. “APracticalWorkbookforCBSEComputerScience(C++)–ClassXI”byPavithra

Karthik,LaxmiPublications2. “APracticalWorkbookforCBSEComputerScience(C++)–ClassXII”byPavithra

Karthik,LaxmiPublications3. “APracticalWorkbookforCBSEComputerScience(Python)–ClassXI”byPavithra

Karthik,LaxmiPublications4. “APracticalWorkbookforCBSEComputerScience(Python)–ClassXII”byPavithra

Karthik,LaxmiPublications5. “COMPREHENSIVECOMPUTERSCIENCEWITHPYTHON–XI”byPavithra

Karthik,LaxmiPublications,20156. “COMPREHENSIVECOMPUTERSCIENCEWITHPYTHON–XII”byPavithra

Karthik,LaxmiPublications,20167. “COMPREHENSIVECOMPUTERSCIENCEWITHC++–XI”byPavithraKarthik,

LaxmiPublications,20168. “COMPREHENSIVECOMPUTERSCIENCEWITHC++–XII”byPavithraKarthik,

LaxmiPublications,2016

Python Programming Made Easy: For Beginners Grade 11 & 12 ...

Documents

Transcript of Python Programming Made Easy: For Beginners Grade 11 & 12 ...

Learn Python for Beginners!

Easy Quiz for beginners

Python Beginners Workbook · 2019-07-26 · Python Beginners Workbook for Secondary Schools Introduction This book aims to be used as a workbook to introduce students to programming

Knitting for Beginners: 6 Easy Free Knitting Patterns for Beginners

Python 3 for Beginners

Hands-On Python A Tutorial Introduction for Beginners Dr. Andrew N

Automation is Easy! (python version)

Easy christmas cake recipe for beginners

Draw Now 30 Easy Exercises for Beginners

Python Beginners Workbook For Secondary Schools...Python Beginners Workbook for Secondary Schools Hanging words off a string - Task 1 In Python, getting the computer to write words

Python for Beginners - CPL Library · 1 Python for Beginners By Edward Smith and Katerina Michalickova 18th September 2017

Python Notes for beginners

Python testing beginners guide

Machine Learning in Python and Jupyter for Beginners...Machine Learning in Python and Jupyter for Beginners Table of Contents 1. Starting the Installation 3 2. Verifying the Installation

Python Easy Script_Manual

Hitchhiker’s Guide to Python and ArcGIS · • Python was designed to be easy to read and learn • Easy to maintain • Excellent for beginners and experts • Suitable for large

Python 101: Python for Absolute Beginners (PyTexas 2014)

Turkish easy reading books for beginners

PYTHON: Easy Python Programming For Beginners, Your Step ...index-of.co.uk/Programming/PYTHON Easy Python Programming.pdf · Python is often used by system admins to create the so-called

Easy Entrepreneurship for Beginners