chunks_pyt123.json

[
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n \n \nPYTHON PROGRAMMING \n[R17A0554] \nLECTURE NOTES  \nB.TECH III  YEAR – II SEM (R17) \n(2019 -20) \n \n \n \n \nDEPARTMENT OF  \nCOMPUTER SCIENCE AND ENGINEERING  \n \nMALLA REDDY COLLEGE OF ENGINEERING & \nTECHNOLOGY  \n(Autonomous Institution – UGC, Govt. of India)  \nRecognized under 2(f) and 12 (B) of UGC ACT 1956  \n(Affiliated to JNTUH, Hyderabad, Approved by AICTE - Accredited by NBA & NAAC – ‘A’ Grade - ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 1
    },
    {
        "content": " 1956  \n(Affiliated to JNTUH, Hyderabad, Approved by AICTE - Accredited by NBA & NAAC – ‘A’ Grade - ISO 9001:2015 \nCertified)  \nMaisammaguda, Dhulapally (Post Via. Hakimpet), Secunderabad – 500100, Telangana State, India  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 1
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n \n SYLLABUS  \nMALLA REDDY COLLEGE OF ENGINEERING AND TECHNOLOGY  \n \nIII Year B. Tech CSE -II SEM        L T/P/D  C \n             3  - / - / -  3 \nOPEN ELECTIVE III  \n(R17A0554) PYTHON PROGRAMMING  \nOBJECTIVES:  \n To read and write simple Python programs.  \n To develop Python programs with conditionals and loops.  \n To define Python functions and call them.  \n To use Python data structures –- li",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 2
    },
    {
        "content": "als and loops.  \n To define Python functions and call them.  \n To use Python data structures –- lists, tuples, dictionaries.  \n To do input/output with files in Python.  \nUNIT I  \nINTRODUC TION DATA, EXPRESSIONS, STATEMENTS  \nIntroduction to Python and installation , data types: Int, float, Boolean, string, and list; variables, \nexpressions, statements, precedence of operators, comments; modules, functions --- function and its \nuse, flow of execut ion, parameters and arguments.  \n \nUNIT II  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 2
    },
    {
        "content": "s, functions --- function and its \nuse, flow of execut ion, parameters and arguments.  \n \nUNIT II  \nCONTROL FLOW, LOOPS  \nConditionals: Boolean values and operators, conditional (if), alternative (if -else), chained conditional \n(if-elif-else); Iteration: while, for, break, continue.  \n \nUNIT III  \nFUNCTIONS, ARRAYS  \nFruitf ul functions: return values, parameters, local and global scope, function composition, \nrecursion; Strings: string slices, immutability, string functions and methods, string",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 2
    },
    {
        "content": " composition, \nrecursion; Strings: string slices, immutability, string functions and methods, string module; Python \narrays, Access the Elements of an Array, array methods.  \n \nUNIT IV  \nLISTS, TUPLES, DICTIONARIES  \nLists: list operations, list slices, list methods, list loop, mutability, aliasing, cloning lists, list \nparameters, list comprehension; Tuples: tuple assignment, tuple as return value, tuple comprehension; \nDictionaries: operatio ns and methods,  comprehension;  \n \nUNIT V  \nFILES, ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 2
    },
    {
        "content": "e, tuple comprehension; \nDictionaries: operatio ns and methods,  comprehension;  \n \nUNIT V  \nFILES, EXCEPTIONS, MODULES, PACKAGES  \nFiles and exception: text files, reading and writing files, command line arguments, errors and \nexceptions, handling exceptions, modules (datetime, time, OS , calendar, math modul e), Explore \npackages.  \n \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 2
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n \n OUTCOMES: Upon completion of the course, students will be able to  \n Read, write, execute by hand simple Python programs.  \n Structure simple Python programs for solving problems.  \n Decompose a Python program into functions.  \n Represent compound data using Python lists, tuples, dictionaries.  \n Read and write data from/to files in Python Programs  \n \n \nTEXT BOOKS  \n1.Allen B. Downey, ``Th",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 3
    },
    {
        "content": "  \n Read and write data from/to files in Python Programs  \n \n \nTEXT BOOKS  \n1.Allen B. Downey, ``Think Python: How to Think Like a Computer Scientist‘‘, 2nd edition, \nUpdated for Python 3, Shroff/O‘Reilly Publis hers, 2016.  \n2.R. Nageswara Rao, “Core Python Programming”, dreamtech  \n3. Python Programming: A Modern Approach, Vamsi Kurama, Pearson  \n \nREFERENCE BOOKS:  \n1. Core Python Programming, W.Chun, Pearson.  \n2. Introduction to Python, Kenneth A. Lambert, Cengage  \n3. Learning Python, Mar",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 3
    },
    {
        "content": " W.Chun, Pearson.  \n2. Introduction to Python, Kenneth A. Lambert, Cengage  \n3. Learning Python, Mark Lutz, Orielly  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 3
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n \n INDEX  \n \nUNIT   \nTOPIC   \nPAGE NO  \n \n \n \n \n \n \n \n \nI INTRODUCTION   DATA, \nEXPRESSIONS, STATEMENTS  1 \nIntroduction to Python and installation  1 \ndata types : Int 6 \nfloat 7 \nBoolean  8 \nstring  8 \nList 10 \nvariables  11 \nexpressions  13 \nstatements  16 \nprecedence o f operators  17 \ncomments  18 \nmodules  19 \nfunctions ---- function and its use  20 \nflow of execution  21 \nparameters and argu",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 4
    },
    {
        "content": "18 \nmodules  19 \nfunctions ---- function and its use  20 \nflow of execution  21 \nparameters and arguments  26 \n \n \n \nII CONTROL FLOW, LOOPS  35 \nConditionals : Boolean values and \noperators,  35 \nconditional (if)  36 \nalternative (if -else)  37 \nchained conditional (if -elif-else)  39 \nIteration: while, for, break, continue.  41 \n \n \n \n \n \nIII FUNCTIONS, ARRAYS  55 \nFruitful functions : return values  55 \nparameters  57 \nlocal and global scope  59 \nfunction composition  62 \nrecursi on 63 \nString",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 4
    },
    {
        "content": "ues  55 \nparameters  57 \nlocal and global scope  59 \nfunction composition  62 \nrecursi on 63 \nStrings: string  slices  64 \nimmutability  66 \nstring functions and methods  67 \nstring module  72 \nPython arrays  73 \nAccess the Elements of an Array  75 \nArray  methods  76 ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 4
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n \n  \n \n \n \n \n \n \n \nIV LISTS, TUPLES, DICTIONARIES  78 \nLists  78 \nlist operations  79 \nlist slices  80 \nlist methods  81 \nlist loop  83 \nmutability  85 \naliasing  87 \ncloning lists  88 \nlist parameters  89 \nlist comprehension  90 \nTuples   91 \ntuple assignment   94 \ntuple as return value  95 \ntuple comprehension  96 \nDictionaries  97 \noperations and method s   97 \ncomprehension  102 \nV FILES, EXCEP",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 5
    },
    {
        "content": "omprehension  96 \nDictionaries  97 \noperations and method s   97 \ncomprehension  102 \nV FILES, EXCEPTIONS, \nMODULES, PACKAGES  103 \nFiles and exception : text files  103 \nreading and writing files   104 \ncommand line arguments  109 \nerrors and exceptions   112 \nhandling exceptions   114 \nmodules (datetime, time, OS , calendar, \nmath module )  121 \nExplore packages  134 \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 5
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n1 \n UNIT – I \nINTRODUCTION DATA, EXPRESSIONS, STATEMENTS  \nIntroduction to Python and installation , data types: Int, float, Boolean, string, and list; \nvariables, expressions, statements, precedence of operators, comments; modules, functions --\n- function and its use, flow of execution, parameters and arguments.  \nIntroduction to Python  and installation : \nPython  is a widely used general -purpos",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 6
    },
    {
        "content": "nd arguments.  \nIntroduction to Python  and installation : \nPython  is a widely used general -purpose, high level programming language. It was initially \ndesigned by Guido van Rossum in 1991  and developed by Python Software Foundation. It \nwas mainly developed for emphasis on code readability, and its syntax allows programme rs \nto express concepts in fewer lines of code.  \nPython is a programming language that lets you work quickly and integrate systems more \nefficiently.   \nThere are two majo",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 6
    },
    {
        "content": "g language that lets you work quickly and integrate systems more \nefficiently.   \nThere are two major Python versions - Python  2 and Python  3. \n \n• On 16 October 2000, Python 2.0 was released wit h many new features.  \n• On 3rd December 2008,  Python 3.0  was released with more testing and includes new \nfeatures.  \n Beginning  with  Python  programming:  \n1) Finding  an Interpreter:  \nBefore we start Python programming, we need to have an interpreter to interpret a nd run our \nprograms. There ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 6
    },
    {
        "content": "start Python programming, we need to have an interpreter to interpret a nd run our \nprograms. There are certain online interpreters like  https://ide.geeksforgeeks.org/ , \nhttp://ideone.com/ or http://codepad.org/  that can be used to start Python without installing \nan interpreter.  \nWindows : There are many interpreters available freely to run Python scripts like IDLE \n(Integrated Development Environment) which is installed when you install the python \nsoftware from  http://python.org/ downloa",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 6
    },
    {
        "content": "vironment) which is installed when you install the python \nsoftware from  http://python.org/ downloads/  \n \n2) Writing  first program:  \n \n# Script Begins  \nStatement1  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 6
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n2 \n Statement2  \nStatement3  \n# Script Ends  \nDifferences  between  scripting  language  and programming  language:  \n \nWhy  to use Python:  \nThe following  are the primary  factors  to use python  in day-to-day life: \n1. Python  is object -oriented  \nStructure  supports  such concepts  as polymorphism,  operation  overloading  and \nmultiple  inheritance.  \n2. Indentation  \nIndentation  is one of t",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 7
    },
    {
        "content": "sm,  operation  overloading  and \nmultiple  inheritance.  \n2. Indentation  \nIndentation  is one of the greatest  feature  in python  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 7
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n3 \n 3. It’s free (open  source)  \nDownloading  python  and installing  python  is free and easy \n4. It’s Powerful  \n Dynamic  typing  \n Built -in types  and tools  \n Library  utilities  \n Third  party  utilities  (e.g. Numeric,  NumPy,  sciPy)  \n Automatic  memory  management  \n5. It’s Portable  \n Python  runs virtually  every  major  platform  used today  \n As long as you have  a compaitabl",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 8
    },
    {
        "content": " \n Python  runs virtually  every  major  platform  used today  \n As long as you have  a compaitable  python  interpreter  installed,  python  \nprograms  will run in exactly  the same  manner,  irrespective  of platform.  \n6. It’s easy to use and learn  \n No intermediate  compile  \n Python  Programs  are compiled  automatically  to an intermediate  form  called  \nbyte code,  which  the interpreter  then reads.  \n This gives  python  the development  speed  of an interpreter  without  the \npe",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 8
    },
    {
        "content": "ter  then reads.  \n This gives  python  the development  speed  of an interpreter  without  the \nperformance  loss inherent  in purely  interpreted  languages.  \n Structure  and syntax  are pretty  intuitive  and easy to grasp.  \n7. Interpreted  Language  \nPython  is processed  at runtime  by python  Interpreter  \n8. Interactive  Programming  Language  \nUsers  can interact  with the python  interpreter  directly  for writing  the programs  \n9. Straight  forward  syntax  \nThe formation  of pyth",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 8
    },
    {
        "content": "rpreter  directly  for writing  the programs  \n9. Straight  forward  syntax  \nThe formation  of python  syntax  is simple  and straight  forward  which  also makes  it \npopular.  \nInstallation:  \nThere are many interpreters available freely to run Python scripts like IDLE (Integrated \nDevelopment Environment) which is installed when you install the python software \nfrom  http://python.org/downloads/  \nSteps  to be followed  and remembered:  \nStep 1: Select  Version  of Python  to Install.  \nStep",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 8
    },
    {
        "content": "s/  \nSteps  to be followed  and remembered:  \nStep 1: Select  Version  of Python  to Install.  \nStep 2: Download  Python  Executable  Installer.  \nStep 3: Run Executable  Installer.  \nStep 4: Verify  Python  Was Installed  On Windows.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 8
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n4 \n Step 5: Verify  Pip Was Installed.  \nStep 6: Add Python  Path to Environment  Variables  (Optional)  \n \n \nWorking  with  Python   \nPython  Code  Execution:  \nPython’s  traditional  runtime  execution  model:  Source  code  you type is translated  to byte \ncode,  which  is then run by the Python  Virtual  Machine  (PVM).  Your  code  is automatically  \ncompiled,  but then it is interpreted.  \n S",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 9
    },
    {
        "content": "Virtual  Machine  (PVM).  Your  code  is automatically  \ncompiled,  but then it is interpreted.  \n Source      Byte  code  Runtime  \n   \n \n \nSource  code  extension  is .py \nByte  code  extension  is .pyc (Compiled  python  code)  \n \nThere  are two modes  for using  the Python  interpreter:  \n• Interactive  Mode  \n• Script  Mode  \n      \n     m.py       \n   m.py c \n   \n    PVM  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 9
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n5 \n  \nRunning  Python  in interactive  mode:  \nWithout  passing  python  script  file to the interpreter,  directly  execute  code  to Python  prompt.  \nOnce  you’re  inside  the python  interpreter,  then you can start. \n>>> print(\"hello  world\")  \nhello  world  \n# Relevant  output  is displayed  on subsequent  lines  without  the >>> symbol  \n>>> x=[0,1,2]  \n# Quantities  stored  in memory  are n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 10
    },
    {
        "content": " subsequent  lines  without  the >>> symbol  \n>>> x=[0,1,2]  \n# Quantities  stored  in memory  are not displayed  by default.  \n>>> x \n#If a quantity  is stored  in memo ry, typing  its name  will display  it. \n[0, 1, 2] \n>>> 2+3 \n5 \n \n \nThe chevron  at the beginning  of the 1st line, i.e., the symbol  >>> is a prompt  the python  \ninterpreter  uses to indicate  that it is ready.  If the programmer  types  2+6, the interpreter  \nreplies  8. \nRunning  Python  in script  mode:  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 10
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n6 \n Alternatively,  programmers  can store  Python  script  source  code  in a file with \nthe .py extension,  and use the interpreter  to execute  the contents  of the file. To execute  the \nscript  by the interpreter,  you have  to tell the interpreter  the name  of the file. For example,  if \nyou have  a script  name  MyFile.py  and you're  working  on Unix,  to run the script  you have  to \ntype",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 11
    },
    {
        "content": "ave  a script  name  MyFile.py  and you're  working  on Unix,  to run the script  you have  to \ntype:  \npython  MyFile.py  \nWorking  with the interactive  mode  is better  when  Python  programmers  deal with small  \npieces  of code  as you can type and execute  them  immediately,  but when  the code  is more  \nthan 2-4 lines,  using  the script  for coding  can help to modify  and use the code  in future.  \nExample:  \n \nData  types : \nThe data stored in memory can be of many types. For example,",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 11
    },
    {
        "content": "n future.  \nExample:  \n \nData  types : \nThe data stored in memory can be of many types. For example, a student roll number  is \nstored as a numeric value and his or her address is stored as alphanumeric characters. Python \nhas various standard data types that are used to define the operations possible on them and \nthe storage method for each of them.  \nInt: \nInt, or integer, is a whole number, positive or negative,   without decimals, of unlimited \nlength.  \n>>> print(24656354687654+2)  \n2465635",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 11
    },
    {
        "content": "itive or negative,   without decimals, of unlimited \nlength.  \n>>> print(24656354687654+2)  \n24656354687656  \n>>> print(20)  \n20 \n>>> print(0b10)  \n2 \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 11
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n7 \n >>> print(0B10)  \n2 \n>>> print(0X20)  \n32 \n>>> 20  \n20 \n>>> 0b10  \n2 \n>>> a=10  \n>>> print(a)  \n10 \n# To verify the type of any object in Python, use the  type()  function:  \n>>> type(10)  \n<class 'int'>  \n>>> a=11  \n>>> print(type(a))  \n<class 'int'>  \nFloat:  \nFloat, or \"floating point number\" is a number, positive or negative, containing one or more \ndecimals.  \nFloat can also be scientific ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 12
    },
    {
        "content": "is a number, positive or negative, containing one or more \ndecimals.  \nFloat can also be scientific numbers with an \"e\" to indicate the power of 10.  \n>>> y=2.8  \n>>> y \n2.8 \n>>> y=2.8  \n>>> print(type(y))  \n<class  'float'>  \n>>> type(.4)  \n<class  'float'>  \n>>> 2. ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 12
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n8 \n 2.0 \nExample:  \nx = 35e3  \ny = 12E4  \nz = -87.7e100   \nprint(type(x))  \nprint(type(y))  \nprint(type(z))  \nOutput:  \n<class 'float'>  \n<class 'float'>  \n<class 'float'>   \nBoolean:  \nObjects  of Boolean  type may have  one of two values,  True  or False:  \n>>> type(True)  \n<class  'bool'>  \n>>> type(False)  \n<class  'bool'>  \nString:  \n1. Strings in Python are identified as a contiguous set of c",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 13
    },
    {
        "content": "pe(False)  \n<class  'bool'>  \nString:  \n1. Strings in Python are identified as a contiguous set of characters represented in the \nquotation marks. Python allows for either pairs of single or double quotes.  \n• 'hello'  is the same as  \"hello\".  \n• Strings can be output to screen using the print function. For example:  print(\"hello\").  \n>>> print(\"mrcet college\")  \nmrcet college  \n>>> type(\"mrcet college\")  \n<class 'str'>  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 13
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n9 \n >>> print('mrcet college')  \nmrcet college  \n>>> \" \"  \n' ' \nIf you want  to include  either  type of quote  character  within  the string,  the simplest  way is to \ndelimit  the string  with the other  type.  If a string  is to contain  a single  quote,  delimit  it with \ndouble  quotes  and vice versa:  \n>>> print(\"mrcet  is an autonomous  (') college\")  \nmrcet  is an autonomous  (') college  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 14
    },
    {
        "content": " versa:  \n>>> print(\"mrcet  is an autonomous  (') college\")  \nmrcet  is an autonomous  (') college  \n>>> print('mrcet  is an autonomous  (\") college')  \nmrcet  is an autonomous  (\") college  \nSuppressing  Special  Character : \nSpecifying  a backslash  (\\) in front  of the quote  character  in a string  “escapes”  it and causes  \nPython  to suppress  its usual  special  meaning.  It is then interpreted  simply  as a literal  single  \nquote  character:  \n>>> print(\"mrcet  is an autonomous  (\\') co",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 14
    },
    {
        "content": "eted  simply  as a literal  single  \nquote  character:  \n>>> print(\"mrcet  is an autonomous  (\\') college\")  \nmrcet  is an autonomous  (') college  \n>>> print('mrcet  is an autonomous  (\\\") college')  \nmrcet  is an autonomous  (\") college  \nThe following  is a table  of escape  sequences  which  cause  Python  to suppress  the usual  \nspecial  interpretation  of a character  in a string:  \n>>> print('a \\ \n....b')  \na....b  \n>>> print('a \\ \nb\\ \nc') ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 14
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n10 \n abc \n>>> print('a  \\n b') \na  \n b \n>>> print(\"mrcet  \\n college\")  \nmrcet   \n college  \n \nEscape  \nSequence  Usual Interpretation of  \nCharacter(s) After Backslash  “Escaped” Interpretation  \n\\' Terminates string with single quote opening delimiter  Literal single quote ( ') character  \n\\\" Terminates string with double quote opening delimiter  Literal double quote ( \") character  \n\\newline  Te",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 15
    },
    {
        "content": "nates string with double quote opening delimiter  Literal double quote ( \") character  \n\\newline  Terminates input line  Newline is ignored  \n\\\\ Introduces escape sequence  Literal backslash ( \\) character  \n \nIn Python  (and almost  all other  common  computer  languages),  a tab character  can be \nspecified  by the escape  sequence  \\t: \n>>> print(\"a \\tb\") \na b \nList:  \n It is a general purpose most widely used in data structures  \n List is a collection which is ordered and changeable and al",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 15
    },
    {
        "content": " most widely used in data structures  \n List is a collection which is ordered and changeable and allows duplicate members. \n(Grow and shrink as needed, sequence type,  sortable).  \n To use a list, you must declare it first. Do this using square brackets and separate \nvalues with commas.  \n We can construct / create list in many ways.  \nEx:  \n>>> list1=[1,2,3,'A', 'B',7,8,[10,11]]  \n>>> print(list1)  \n[1, 2, 3, 'A', 'B', 7, 8, [10, 11]]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 15
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n11 \n ----------------------  \n>>> x=list()  \n>>> x  \n[] \n--------------------------  \n>>> tuple1=(1,2,3,4)  \n>>> x=list(tuple1)  \n>>> x  \n[1, 2, 3, 4]  \nVariables : \nVariables  are nothing  but reserved  memory  locations  to store  values.  This means  that when  \nyou create  a variable  you reserve  some  space  in memory.  \nBased  on the data type of a variable,  the interpreter  allocates  memo",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 16
    },
    {
        "content": "  some  space  in memory.  \nBased  on the data type of a variable,  the interpreter  allocates  memory  and decides  what  can \nbe stored  in the reserved  memory.  Therefore,  by assigning  different  data types  to variables,  \nyou can store  integers,  decimals  or characters  in these  variables.  \nRules  for Python  variables:  \n• A variable  name  must  start with a letter  or the underscore   character  \n• A variable  name  cannot  start with a number  \n• A variable  name  can only contai",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 16
    },
    {
        "content": "   character  \n• A variable  name  cannot  start with a number  \n• A variable  name  can only contain  alpha -numeric  characters  and underscores  (A-z, 0-9, \nand _ ) \n• Variable  names  are case-sensitive  (age,  Age and AGE  are three  different  variables)  \nAssigning  Values  to Variables:  \nPython  variables  do not need  explicit  declaration  to reserve  memory  space.  The declaration  \nhappens  automatically  when  you assign  a value  to a variable.  The equal  sign (=) is used to \nas",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 16
    },
    {
        "content": "appens  automatically  when  you assign  a value  to a variable.  The equal  sign (=) is used to \nassign  values  to variables.  \nThe operand  to the left of the = operator  is the name  of the variable  and the operand  to the \nright  of the = operator  is the value  stored  in the variable.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 16
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n12 \n  For example  − \na= 100           # An integer  assignment  \nb = 1000.0             # A floating  point   \nc = \"John\"           # A string   \nprint  (a) \nprint  (b) \nprint  (c) \nThis  produces  the following  result  − \n100  \n1000.0   \nJohn  \nMultiple  Assignment:  \nPython  allows  you to assign  a single  value  to several  variables  simultaneously.   \nFor example  : \na = b = c = 1 \nHere,  a",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 17
    },
    {
        "content": "  a single  value  to several  variables  simultaneously.   \nFor example  : \na = b = c = 1 \nHere,  an integer  object  is created  with the value  1, and all three  variables  are assigned  to the \nsame  memory  location.  You can also assign  multiple  objects  to multiple  variables.   \nFor example  − \na,b,c  = 1,2,\"mrcet“  \nHere,  two integer  objects  with values  1 and 2 are assigned  to variables  a and b respectively,  \nand one string  object  with the value  \"john\"  is assigned  to the v",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 17
    },
    {
        "content": "ables  a and b respectively,  \nand one string  object  with the value  \"john\"  is assigned  to the variable  c. \nOutput  Variables:  \nThe Python  print  statement  is often  used to output  variables.  \nVariables  do not need  to be declared  with any particular  type and can even  change  type after \nthey have  been  set.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 17
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n13 \n x = 5                 # x is of type int \nx = \"mrcet  \"       # x is now of type str \nprint(x)  \nOutput:  mrcet  \nTo combine  both text and a variable,  Python  uses the “+” character:  \nExample  \nx = \"awesome\"  \nprint(\"Python  is \" + x) \nOutput  \nPython  is awesome  \nYou can also use the + character  to add a variable  to another  variable:  \nExample  \nx = \"Python  is \" \ny = \"awesome\"  \nz = x",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 18
    },
    {
        "content": "acter  to add a variable  to another  variable:  \nExample  \nx = \"Python  is \" \ny = \"awesome\"  \nz = x + y \nprint(z)  \nOutput:  \nPython  is awesome   \nExpressions:  \nAn expression  is a combination  of values,  variables,  and operators.  An expression  is \nevaluated  using  assignment  operator.  \nExamples:  Y=x + 17 \n>>> x=10  \n>>> z=x+20  \n>>> z \n30 ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 18
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n14 \n  \n>>> x=10  \n>>> y=20  \n>>> c=x+y  \n>>> c \n30 \nA value  all by itself  is a simple  expression,  and so is a variable.  \n>>> y=20  \n>>> y \n20 \nPython  also defines  expressions  only contain  identifiers,  literals,  and operators.  So,  \nIdentifiers:  Any name  that is used to define  a class,  function,  variable  module,  or object  is \nan identifier.   \nLiterals:  These  are language -inde",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 19
    },
    {
        "content": " function,  variable  module,  or object  is \nan identifier.   \nLiterals:  These  are language -independent  terms  in Python  and should  exist  independently  in \nany programming  language.  In Python,  there  are the string  literals,  byte literals,  integer  \nliterals,  floating  point  literals,  and imaginary  literals.   \nOperators:  In Python  you can implement  the following  operations  using  the corresponding  \ntokens.  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 19
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n15 \n  \nOperator  Token  \nadd + \nsubtract  - \nmultiply  * \nInteger  Division  / \nremainder  % \nBinary  left shift << \nBinary  right  shift >> \nand & \nor \\ \nLess than < \nGreater  than > \nLess than or equal  to <= \nGreater  than or equal  to >= \nCheck  equality  == \nCheck  not equal  != ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 20
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n16 \n Some  of the python  expressions  are: \nGenerator  expression:  \nSyntax:  ( compute(var)  for var in iterable  ) \n \n>>> x = (i for i in 'abc')   #tuple comprehension  \n>>> x  \n<generator object <genexpr> at 0x033EEC30>  \n \n>>> print(x)  \n<generator object <genexpr> at 0x033EEC30>  \n \nYou might expect this to print as ('a', 'b', 'c') but it prints as <generator object <genexpr> \nat 0x02AAD710> ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 21
    },
    {
        "content": "xpect this to print as ('a', 'b', 'c') but it prints as <generator object <genexpr> \nat 0x02AAD710> The result of a tuple comprehension is not a tuple: it is actually a \ngenerator. The only thing that you need to know now about a generator now is that you \ncan iterate over it, but ONLY ONCE.  \n \nConditio nal expression:  \nSyntax:  true_value  if Condition  else false_value  \n>>> x = \"1\" if True  else \"2\" \n>>> x \n'1' \nStatements:  \nA statement  is an instruction that the Python interpreter can ex",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 21
    },
    {
        "content": "lse \"2\" \n>>> x \n'1' \nStatements:  \nA statement  is an instruction that the Python interpreter can execute. We have normally  two \nbasic statements , the assignment statement and the print  statement. Some other kinds of \nstatements that are  if statements,  while  statements, and  for statements  generally calle d as \ncontrol flows.  \nExamples:  \nAn assignment statement creates new variables and gives them values:  \n>>> x=10  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 21
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n17 \n >>> college=\"mrcet\"  \nAn print statement is something which is an input from the user, to be printed / displayed on \nto the screen (or ) monitor.  \n>>> p rint(\"mrcet colege\")  \nmrcet college  \nPrecedence of Operators:  \nOperator precedence affects how an expression is evaluated.  \nFor example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher \nprecedence than +, so it",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 22
    },
    {
        "content": " = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher \nprecedence than +, so it first multiplies 3*2 and then adds into 7.  \nExample  1: \n>>> 3+4*2  \n11 \nMultiplication gets evaluated before the addition operation  \n>>> (10+10)*2  \n40 \nParentheses () overriding the  precedence of the arithmetic operators  \nExample 2:  \na = 20  \nb = 10  \nc = 15  \nd = 5  \ne = 0  \n \ne = (a + b) * c / d       #( 30 * 15 ) / 5  \nprint(\"Value of (a + b) * c / d is \",  e)  \n \ne = ((a + b) * c) / d ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 22
    },
    {
        "content": " c / d       #( 30 * 15 ) / 5  \nprint(\"Value of (a + b) * c / d is \",  e)  \n \ne = ((a + b) * c) / d     # (30 * 15 ) / 5  \nprint(\"Value of ((a + b) * c) / d is \",  e)  \n \ne = (a + b) * (c / d);    # (30) * (15/5)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 22
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n18 \n print(\"Value of (a + b) * (c / d) is \",  e)  \n \ne = a + (b * c) / d;      #  20 + (150/5)  \nprint(\"Value of a + (b * c) / d is \",  e)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/opprec.py  \nValue of (a + b) * c / d is  90.0  \nValue of ((a + b) * c) / d is  90.0  \nValue of (a + b) * (c / d) is  90.0 \nValue of a + (b * c) / d is  50.0  \n \nComments:  \nSingle -line",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 23
    },
    {
        "content": "\nValue of (a + b) * (c / d) is  90.0 \nValue of a + (b * c) / d is  50.0  \n \nComments:  \nSingle -line comments  begin s with a hash(#)  symbol  and is useful  in mentioning  that the \nwhole  line should  be considered  as a comment  until the end of line. \nA Multi  line comment  is useful  when  we need  to comment  on many  lines.  In python,  triple  \ndouble  quote(“  “ “) and single  quote(‘  ‘ ‘)are  used for multi -line commenting.  \nExample:  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Progra",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 23
    },
    {
        "content": "‘)are  used for multi -line commenting.  \nExample:  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/comm.py  \n30 \n  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 23
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n19 \n Modules:  \nModules:  Python  module  can be defined  as a python  program  file which  contains  a python  \ncode  including  python  functions,  class,  or variables.  In other  words,  we can say that our \npython  code  file saved  with the extension  (.py)  is treated  as the module.  We may have  a \nrunnable  code  inside  the python  module.  A module  in Python  provides  us the flexibili",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 24
    },
    {
        "content": "ave  a \nrunnable  code  inside  the python  module.  A module  in Python  provides  us the flexibility  to \norganize  the code  in a logical  way.  To use the functionality  of one module  into another,  we \nmust  have  to import  the specific  module.  \nSyntax:  \nimport   <module -name>  \nEvery  module  has its own functions,  those  can be accessed  with  . (dot)  \nNote:  In python  we have  help ()  \nEnter  the name  of any module,  keyword,  or topic  to get help on writing  Python  programs",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 24
    },
    {
        "content": "p ()  \nEnter  the name  of any module,  keyword,  or topic  to get help on writing  Python  programs  \nand using  Python  modules.   To quit this help utility  and return  to the interpreter,  just type \n\"quit\".  \nSome  of the modules  like os, date,  and calendar  so on……  \n>>> import  sys \n>>> print(sys.version)  \n3.8.0  (tags/v3.8.0:fa919fd,  Oct 14 2019,  19:21:23)  [MSC  v.1916  32 bit (Intel)]  \n>>> print(sys.version_info)  \nsys.version_info(major=3,  minor=8,  micro=0,  releaselevel='fina",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 24
    },
    {
        "content": ")]  \n>>> print(sys.version_info)  \nsys.version_info(major=3,  minor=8,  micro=0,  releaselevel='final',  serial=0)  \n>>> print(calendar.month(2021,5))  \n \n>>> print(calendar.isleap(2020))  \nTrue  \n>>> print(calendar.isleap(2017))  \nFalse  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 24
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n20 \n Functions:  \nFunctions and its use: Function is a group of related statements that perform a specific task.  \nFunctions help break our program into smaller and modular chunks. As our program grows \nlarger and larger, functions make it more organized and manageable. It avoids repetition and \nmakes code reusable.  \nBasically, we can divide functions into the following two types:  \n1. Built -in f",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 25
    },
    {
        "content": "s code reusable.  \nBasically, we can divide functions into the following two types:  \n1. Built -in functions  - Functions that are built into Python.  \nEx: abs(),all().ascii(),bool()………so on….  \ninteger = -20 \nprint('Absol ute value of -20 is:', abs(integer))  \nOutput:  \nAbsolute value of -20 is: 20  \n2. User -defined functions  - Functions defined by the users themselves.  \ndef add_numbers(x ,y): \n   sum = x + y  \n   return sum  \n \nprint(\"The sum is\", add_numbers( 5, 20)) \nOutput:  \nThe sum is ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 25
    },
    {
        "content": " \n   sum = x + y  \n   return sum  \n \nprint(\"The sum is\", add_numbers( 5, 20)) \nOutput:  \nThe sum is 25  \n \nFlow of Execution:  \n1. The order in which statements are executed is called the  flow of execution  \n2. Execution always begins at the first statement of the program.  \n3. Statements are executed one at a time, in order, from top to bottom.  \n4. Function definitions do not alter the flow of execution of the program, but remember \nthat statements inside the function are not executed until t",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 25
    },
    {
        "content": "execution of the program, but remember \nthat statements inside the function are not executed until the function is called.  \n5. Function calls are like a bypass in the flow of execution. Instead of going to the  next \nstatement, the flow jumps to the first line of the called function, executes all the \nstatements there, and then comes back to pick up where it left off.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 25
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n21 \n   \nNote:  When you read a program, d on’t read from top to bottom. Instead, follow the flow  of \nexecution. This means that you will read the  def statements as you are scanning from top to \nbottom, but you should skip the statements of the function definition until you reach a point \nwhere that f unction is called.  \nExample:  \n#example for flow of execution  \n print(\"welcome\")  \nfor x in ran",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 26
    },
    {
        "content": " f unction is called.  \nExample:  \n#example for flow of execution  \n print(\"welcome\")  \nfor x in range(3):  \n    print(x)  \nprint(\"Good morning college\")  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/flowof.py  \nwelcome  \n0 \n1 \n2 \nGood morning college  \nThe flow/order of execution is: 2,3,4,3,4,3,4,5  \n \n------------------------------------------  \n \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 26
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n22 \n Output:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/flowof.py  \nhi \nhello  \nGood morning  \nmrcet  \ndone!  \nThe flow/order of execution is: 2,5,6,7,2,3,4,7 ,8 \n \nParameters  and arguments:  \n \nParameters are passed during the definition of function while Arguments are passed during \nthe function call . \n \nExample:  \n#here a and b are parameters  \n \ndef add(a,b): #//function",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 27
    },
    {
        "content": "during \nthe function call . \n \nExample:  \n#here a and b are parameters  \n \ndef add(a,b): #//function definition  \n return a+b  \n  \n#12 and 13 are arguments  \n#function call  \nresult=add(12,13)  \nprint(result)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/paraarg.py  \n25 \nThere are three types of Python function arguments using which we can call a function.  \n1. Default Arguments  \n2. Keyword Arguments  \n3. Variable -length Arguments  \n \nSyntax:  \ndef functionname()",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 27
    },
    {
        "content": "lt Arguments  \n2. Keyword Arguments  \n3. Variable -length Arguments  \n \nSyntax:  \ndef functionname():  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 27
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n23 \n  statements  \n    . \n    . \n    . \nfunctionname()  \n \nFunction definition consists of following components : \n \n1. Keyword  def indicate s the start of function header.  \n2. A function name to uniquely identify it. Functio n naming follows the same  rules of writing \nidentifiers in Python . \n3. Parameters (arguments) through which we pass values to a function. They are optional.  \n4. A colon (",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 28
    },
    {
        "content": "Parameters (arguments) through which we pass values to a function. They are optional.  \n4. A colon (:)  to mark the end of function header.  \n5. Optional documentation string (docstring) to describe what the function does.  \n6. One or more valid python statements that make up the function body. Statements must have \nsame indentation level  (usually 4 spaces).  \n7. An optional  return  statement to return a value from the function.  \n \nExample:  \n \ndef hf():  \n    hello world  \nhf() \nIn the above",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 28
    },
    {
        "content": " return a value from the function.  \n \nExample:  \n \ndef hf():  \n    hello world  \nhf() \nIn the above example we are just trying to execute the program by calling the function. So it \nwill not display any error and no  output on to the screen but gets executed.  \nTo get the statements of function need to be use print().  \n#calling function in python:  \ndef hf():  \n    print(\"hello world\")  \nhf() \nOutput:  \nhello world  \n-------------------------------  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 28
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n24 \n def hf():  \n    print(\"hw\")  \n    print(\"gh kfjg 66666\")  \nhf() \nhf() \nhf() \nOutput:  \nhw \ngh kfjg 66666  \nhw \ngh kfjg 66666  \nhw \ngh kfjg 66666  \n---------------------------------  \ndef add(x,y):  \n    c=x+y  \n    print(c)  \nadd(5,4)  \nOutput:  \n9 \ndef add(x,y):  \n    c=x+y  \n    return c  \nprint(add(5,4))  \nOutput:  \n9 \n-----------------------------------  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 29
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n25 \n  \ndef add_sub(x,y):  \n    c=x+y  \n    d=x-y \n    return c,d  \nprint(add_sub(10,5))  \nOutput:  \n (15, 5)  \nThe return  statement is used to exit a function and go back to the place from where it was \ncalled . This statement can contain expression which gets evaluated and the value is returned. \nIf there is no expression in the statement or the  return  statement itself is not present inside a \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 30
    },
    {
        "content": "f there is no expression in the statement or the  return  statement itself is not present inside a \nfunction, then the function will return the  None  object.  \ndef hf():  \n    return \"hw\"  \nprint(hf())  \nOutput:  \nhw \n----------------------------  \n \ndef hf():  \n    return \"hw\"  \nhf() \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs /Python/Python38 -32/pyyy/fu.py  \n>>> ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 30
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n26 \n -------------------------------------  \ndef hello_f():  \n    return \"hello college \" \nprint(hello_f().upper())  \nOutput:  \nHELLOCOLLEGE  \n# Passing Arguments  \ndef hello(wish):  \n    return '{}'.format(wish)  \nprint(hello(\" mrcet \")) \nOutput:  \nmrcet \n------------------------------------------------  \nHere, the function  wish () has two parameters.  Since, we have called this function with two",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 31
    },
    {
        "content": "----  \nHere, the function  wish () has two parameters.  Since, we have called this function with two \narguments, it runs smoothly and we do not get any error.  If we call it with different number \nof arguments, the interpreter will give errors .  \ndef wish(name,msg):  \n   \"\"\"This function greets to  \n   the person with the provided message\"\"\"  \n       print (\"Hello\",name +  '   ' + msg)  \nwish(\"MRCET\",\"Good morning!\")  \nOutput:  \nHello MRCET Good morning!  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 31
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n27 \n Below is a call to this function with one and no arguments along with their respective error \nmessages.  \n>>> wish (\"MRCET \")    # only one argument  \nTypeError: wish () missing 1 required positional argument: 'msg'  \n>>> wish ()    # no arguments  \nTypeError: wish () missing 2 required positional arguments: 'name' and 'msg'  \n \n----------------------------------------------  \ndef hello(wish,h",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 32
    },
    {
        "content": "al arguments: 'name' and 'msg'  \n \n----------------------------------------------  \ndef hello(wish,hello):  \n    return  “hi”  '{},{}'.format( wish,hello)  \nprint(hello(\" mrcet \",\"college \")) \nOutput:  \nhimrcet,college  \n#Keyword  Arguments  \nWhen we call a function with some values, these values get assigned to the arguments \naccording to their position . \nPython allows functions to be called using keyword arguments. When we call functions in \nthis way, the order (position) of the arguments can",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 32
    },
    {
        "content": "ng keyword arguments. When we call functions in \nthis way, the order (position) of the arguments can be changed.   \n(Or) \nIf you have some functions with many parameters and you want to specify only some \nof them, then you can give values for such parameters by naming them - this is \ncalled  keyword arguments  - we use the name (keyword) instead of the position \n(which we have been using all along) to specify the arguments to the function.  \nThere are two  advantages  - one, using the function i",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 32
    },
    {
        "content": ") to specify the arguments to the function.  \nThere are two  advantages  - one, using the function is easier since we do not need to \nworry about the order of the arguments. Two, we can give values to only those \nparameters which we want, provided that the other parameters have default argument \nvalues.  \ndef func(a, b=5, c=10):  \n   print 'a is', a, 'and b is', b, 'and c is', c  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 32
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n28 \n  \nfunc(3, 7)  \nfunc(25, c=24)  \nfunc(c=50, a=100)  \n \nOutput:  \na is 3 and b is 7 and c is 10  \na is 25 and b is 5 and c is 24  \na is 100 and b is 5 and c is 50  \n \nNote:  \nThe function named  func has one parameter without default argument values, \nfollowed by two parameters with default a rgument values.  \nIn the first usage,  func(3, 7), the parameter  a gets the value  3, the parameter  b ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 33
    },
    {
        "content": "ent values.  \nIn the first usage,  func(3, 7), the parameter  a gets the value  3, the parameter  b gets the \nvalue  5 and c gets the default value of  10. \nIn the second usage  func(25, c=24), the variable  a gets the value of 25 due to the \nposition of the argume nt. Then, the parameter  c gets the value of  24 due to naming i.e. \nkeyword arguments. The variable  b gets the default  value of  5. \nIn the third usage  func(c=50, a=100), we use keyword arguments completely to \nspecify the values.",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 33
    },
    {
        "content": " \nIn the third usage  func(c=50, a=100), we use keyword arguments completely to \nspecify the values. Notice, that we are specifying  value for parameter  c before that \nfor a even though  a is defined before  c in the function definition.  \nFor example: if you define the function like below  \ndef func(b=5, c=10,a):   # shows error : non-default argument follows default argument  \n-------------------------------------------------------  \ndef print_name(name1, name2):  \n  \"\"\" This function prints ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 33
    },
    {
        "content": "--------------------------------------  \ndef print_name(name1, name2):  \n  \"\"\" This function prints the name \"\"\"  \n  print (name1 + \" and \" + name2 + \" are friends\")  \n#calling the function  \nprint_name(name2 = 'A',name1 = 'B')  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 33
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n29 \n Output:  \nB and A are friends  \n#Default Arguments  \nFunction arguments can have default values in Python.  \nWe can provide a default value to an argument by using the assignment operator (=)  \ndef hello(wish,name='you'):  \n    return '{},{}'.format(wish,name)  \nprint(hello(\" good morning \")) \nOutput:  \ngood morning,you  \n---------------------------------------------  \ndef hello(wish,name='you",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 34
    },
    {
        "content": "utput:  \ngood morning,you  \n---------------------------------------------  \ndef hello(wish,name='you'):  \n    return '{},{}'.format(wish,name)      //print(wish  +  ‘  ‘ +  name)  \nprint(hello(\"good morning\",\"nirosha\"))    // hello(\"good morning\",\"nirosha\")     \nOutput:  \ngood morning,nirosha    //     good morning  nirosha  \nNote:  Any number of arguments in a function can have a default value. But once we have a \ndefault argument, all the arguments to its right must also have default values.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 34
    },
    {
        "content": "ut once we have a \ndefault argument, all the arguments to its right must also have default values.  \nThis means to say, non -default arguments cannot follow default arguments. For example, if \nwe had defined the function header above as:  \ndef hello(name=' you', wish ): \nSyntax Error: non -default argument follows default argument  \n------------------------------------------  \ndef sum(a=4, b=2): #2 is supplied as default argument  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 34
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n30 \n   \"\"\" This function will print sum of two numbers  \n      if the arguments are not supplied  \n      it will add the default value \"\"\"  \n  print (a+b)  \nsum(1,2)  #calling with arguments  \nsum( )    #calling without arguments  \nOutput:  \n3 \n6 \nVariable -length arguments  \nSometimes you may need more arguments to process function then you mentioned in the \ndefinition. If we don’t know in advance",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 35
    },
    {
        "content": "ore arguments to process function then you mentioned in the \ndefinition. If we don’t know in advance about the arguments needed in function, we can use \nvariable -length arguments also called arbit rary arguments.  \nFor this an asterisk (*) is placed before a parameter in function definition which can hold \nnon-keyworded variable -length arguments and a double asterisk (**) is placed before a \nparameter in function which can hold keyworded variable -length  arguments.  \nIf we use one asterisk (*",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 35
    },
    {
        "content": "ameter in function which can hold keyworded variable -length  arguments.  \nIf we use one asterisk (*) like *var,   then all the positional arguments from that point till the \nend are collected as a  tuple  called ‘var’ and if we use two asterisks (**) before a variable like \n**var,   then all the positional arguments from that point till the end are collected as \na dictionary  called ‘var’.  \n \ndef wish(*names):  \n   \"\"\"This function greets all  \n   the person in the names tuple.\"\"\"  \n \n   # nam",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 35
    },
    {
        "content": "f wish(*names):  \n   \"\"\"This function greets all  \n   the person in the names tuple.\"\"\"  \n \n   # names is a tuple with arguments  \n   for name in names:  \n       print(\"Hello\",name)  \n \nwish(\"MRCET\",\"CSE\",\"SIR\",\"MADAM\")  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 35
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n31 \n  \nOutput:  \nHello MRCET  \nHello CSE  \nHello SIR  \nHello MADAM  \n \n#Program to find area of a circle using function use single return value function with \nargument.  \npi=3.14  \ndef areaOfCircle(r):  \n     \n    return pi*r*r  \nr=int(input(\"Enter radius of circle\"))  \n       \nprint(areaOfCircle(r))  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nEnter radius ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 36
    },
    {
        "content": "  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nEnter radius of circle 3  \n28.259999999999998  \n \n#Program to write sum different product and   using arguments with return value \nfunction.  \ndef calculete(a,b):  \n    total=a+b  \n    diff=a -b \n    prod=a*b  \n    div=a/b  \n    mod=a%b  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 36
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n32 \n     return total,diff,prod,div,mod  \na=int(input(\"Enter a value\"))  \nb=int(input(\"Enter b value\"))  \n #function call      \ns,d,p,q,m = calculete(a,b)  \nprint(\"Sum= \",s,\"diff= \",d,\"mul= \",p,\"div= \",q,\"mod= \",m)  \n#print(\"diff= \",d)  \n#print(\"mul= \",p)  \n#print(\"div= \",q)  \n#print(\"mod= \",m)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nEnter a value 5  \nE",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 37
    },
    {
        "content": "utput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nEnter a value 5  \nEnter b value 6  \nSum=  11 diff=  -1 mul=  30 div=  0.8333333333333334 mod=  5  \n \n#program to find biggest of two numbers using functions.  \ndef biggest(a,b):  \n    if a>b :  \n        return a  \n    else :  \n        return b  \n     \n    \na=int(input(\"Enter a value\"))  \nb=int(input(\"Enter b value\"))  \n #function call      \nbig= biggest(a,b)  \nprint(\"big number= \",big)  \n \nOutput:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 37
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n33 \n C:/Users/MRC ET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nEnter a value 5  \nEnter b value -2 \nbig number=  5  \n#program to find biggest of two numbers using functions.  (nested if)  \n \ndef biggest(a,b,c):  \n    if a>b :  \n        if a>c :  \n            return a  \n        else :  \n            return c  \n    else :  \n        if b>c :  \n            return b  \n        else :  \n     ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 38
    },
    {
        "content": "            return c  \n    else :  \n        if b>c :  \n            return b  \n        else :  \n            return c  \n   \n     \na=int(input(\"Enter a value\"))  \nb=int(input(\"Enter b value\"))  \nc=int(input(\"Enter c value\"))  \n #function call      \nbig= biggest(a,b ,c) \nprint(\"big number= \",big)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nEnter a value 5  \nEnter b value -6 \nEnter c value 7  \nbig number=  7  \n \n#Writer a program to read one subject mark and ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 38
    },
    {
        "content": "ter b value -6 \nEnter c value 7  \nbig number=  7  \n \n#Writer a program to read one subject mark and print pass or fail use single return  \nvalues function with argument.  \ndef result(a):  \n    if a>40:  \n       return \"pass\"  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 38
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n34 \n     else: \n        return \"fail\"  \na=int(input(\"Enter one subject marks\"))  \n \nprint(result(a))  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nEnter o ne subject marks 35  \nfail \n \n#Write a program to display mrecet cse dept 10 times on the screen.  (while loop)  \ndef usingFunctions():  \n    count =0  \n    while count<10:  \n        print(\"mrcet cse dept\",",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 39
    },
    {
        "content": "loop)  \ndef usingFunctions():  \n    count =0  \n    while count<10:  \n        print(\"mrcet cse dept\",count)  \n        count=count+1  \n \nusingFunctions()  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nmrcet cse dept 0  \nmrcet cse dept 1  \nmrcet cse dept 2  \nmrcet cse dept 3  \nmrcet cse dept 4  \nmrcet cse dept 5  \nmrcet cse dept 6  \nmrcet cse dept 7  \nmrcet cse dept 8  \nmrcet cse dept 9  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 39
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n35 \n UNIT – II \nCONTR OL FLOW, LOOPS  \nConditionals:  Boolean values and operators, conditional (if), alternative (if -else), chained \nconditional (if -elif-else); Iteration: while, for, break, continue.  \nControl Flow, Loops : \nBoolean Values and Operators:  \nA boolean expression is an expression that is either true or false. The following examples \nuse the operator ==, which compares two operands",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 40
    },
    {
        "content": "at is either true or false. The following examples \nuse the operator ==, which compares two operands and produces True if they are equal and \nFalse otherwise:  \n>>> 5 == 5  \nTrue  \n>>> 5 == 6  \nFalse  \nTrue and False are special values that belong to the type bool; they are not strings:  \n>>> type(True)  \n<class 'bool'>  \n>>> type(False)  \n<class 'bool'>  \nThe == operator is one of the relational operators; the others are: x != y # x is not equal to y  \nx > y # x is greater than y x < y # x is l",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 40
    },
    {
        "content": "operators; the others are: x != y # x is not equal to y  \nx > y # x is greater than y x < y # x is less than y  \nx >= y # x i s greater than or equal to y x <= y # x is less than or equal to y  \nNote:  \nAll expressions involving relational and logical operators will evaluate to either true or false  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 40
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n36 \n Conditional (if):  \nThe if statement contains a logical expression using which data is  compared and a decision \nis made based on the result of the comparison.  \nSyntax:  \nif expression:  \n    statement(s)  \nIf the boolean expression evaluates to TRUE, then the block of statement(s) inside the if \nstatement is executed. If boolean expression evaluates  to FALSE, then the first set of \ncode aft",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 41
    },
    {
        "content": "f \nstatement is executed. If boolean expression evaluates  to FALSE, then the first set of \ncode after the end of the if statement(s) is executed.  \nif Statement Flowchart : \n \n                   Fig: Operation of if statement  \nExample: Python if Statement  \na = 3  \nif a > 2:  \n    print(a, \"is greater\")  \nprint(\"done\")  \n \na = -1 \nif a < 0:  \n     print(a, \"a is smaller\")  \nprint(\"F inish\")  \n \nOutput:  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 41
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n37 \n  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/if1.py  \n3 is greater  \ndone  \n-1 a is smaller  \nFinish  \n--------------------------------  \na=10  \nif a>9:  \n    print(\"A is Greater than 9\" ) \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/if2.py  \nA is Greater than 9  \nAlternative i f (If-Else):  \nAn else statement can be combined with an if statemen",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 42
    },
    {
        "content": " Greater than 9  \nAlternative i f (If-Else):  \nAn else statement can be combined with an if statement. An else statement contains the \nblock of code (false block) that executes if  the conditional expression in the if statement \nresolves to 0 or a FALSE value.  \nThe else statement is an optional statement and there could be at most only one else  \nStatement following if.  \nSyntax of if - else : \nif test expression:  \n Body of if  stmts  \nelse: \n Body of else  stmts  \nIf - else Flowchart : ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 42
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n38 \n         \n             Fig: Operation of if – else statement  \nExample of if - else: \na=int(input('enter the number'))  \nif a>5:  \n    print(\"a is greater\")  \nelse: \n    print(\"a is smaller than the input given\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ifelse.py  \nenter the number 2  \na is smaller than the input given  \n--------------------------------------",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 43
    },
    {
        "content": "py  \nenter the number 2  \na is smaller than the input given  \n----------------------------------------  \na=10  \nb=20  \nif a>b:  \n    print(\"A is Greater than B\")  \nelse: \n    print(\"B is Greater than A\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/if2.py  \nB is Greater than A  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 43
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n39 \n  \nChained Conditional: (If -elif-else): \n \nThe elif statement allows us to check multiple expressions for TRUE and execute a \nblock of code as soon as one of the c onditions evaluates to TRUE. Similar to the else, \nthe elif statement is optional. However, unlike else, for which there can be at most one \nstatement, there can be an arbitrary number of elif statements following an if.  \nSyntax of",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 44
    },
    {
        "content": "ost one \nstatement, there can be an arbitrary number of elif statements following an if.  \nSyntax of if – elif - else : \nIf test expression:  \n Body of if stmts  \nelif test expression:  \n Body of elif stmts  \nelse: \n Body of else stmts  \n \nFlowchart of if – elif - else:  \n     \n                         Fig: Operation of if – elif - else statement  \n Example of if - elif – else:  \na=int(input('enter the number'))  \nb=int(input('enter the number'))  \nc=int(input('enter the number'))  \nif a>b:  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 44
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n40 \n     print(\"a is greater\")  \nelif b>c:  \n    print(\"b is greater\")  \nelse: \n    print(\"c is greater\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ife lse.py  \nenter the number5  \nenter the number2  \nenter the number9  \na is greater  \n>>>  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ifelse.py  \nenter the number2  \nenter the number5  \nenter the",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 45
    },
    {
        "content": "ocal/Programs/Python/Python38 -32/pyyy/ifelse.py  \nenter the number2  \nenter the number5  \nenter the number9  \nc is greater  \n-----------------------------  \nvar = 100 \nif var == 200:  \n    print(\"1 - Got a true expression value\")  \n    print(var)  \nelif var == 150:  \n    print(\"2 - Got a true expression value\")  \n    print(var)  \nelif var == 100:  \n    print(\"3 - Got a true expression value\")  \n    print(var)  \nelse: \n    print(\"4 - Got a false expression value\")  \n    print(var)  \nprint(\"Good ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 45
    },
    {
        "content": "   print(var)  \nelse: \n    print(\"4 - Got a false expression value\")  \n    print(var)  \nprint(\"Good bye!\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ifelif.py  \n3 - Got a true expression value  \n100 \nGood bye!  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 45
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n41 \n Iteration:  \nA loop statement allows us to execute a statement or group of statements multiple times  as \nlong as the condition is true . Repeated execution of a set of statements with the help of loops \nis called iteration.  \nLoops statements are used when we need to run same code again and again, each time with a \ndifferent v alue.  \n \nStatements:  \nIn Python Iteration (Loops) statements are",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 46
    },
    {
        "content": "in, each time with a \ndifferent v alue.  \n \nStatements:  \nIn Python Iteration (Loops) statements are of three types:  \n1. While Loop  \n2. For Loop  \n3. Nested For Loops  \nWhile loop : \n Loops are either infinite or conditional. Python  while  loop keeps reiterating a block of \ncode defined inside it until the desired condition is met.  \n The while  loop contains a boolean expression and the code inside the loop is \nrepeatedly executed as long as the boolean expression is true.  \n The statemen",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 46
    },
    {
        "content": " inside the loop is \nrepeatedly executed as long as the boolean expression is true.  \n The statements that are executed inside while can be a single line of code or a block of \nmultiple statements.  \nSyntax:       \n \n                  while(expression):  \n   Statement(s)  \n \nFlowchart:  \n   \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 46
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n42 \n Example Programs:  \n1. --------------------------------------  \ni=1 \n     while i<=6:  \n      print(\"Mrcet college\")  \n      i=i+1  \noutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/wh1.py  \nMrcet college  \nMrcet college  \nMrcet college  \nMrcet college  \nMrcet college  \nMrcet college  \n2.   -----------------------------------------------------   \ni=1 \n \nwhile i<=3:  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 47
    },
    {
        "content": "rcet college  \n2.   -----------------------------------------------------   \ni=1 \n \nwhile i<=3:  \n    print(\"MRCET\",end=\"  \")  \n    j=1 \n    while j<=1:  \n        print(\"CSE DEPT\",end=\"\")  \n        j=j+1  \n    i=i+1  \n    print()  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/wh2.py  \nMRCET  CSE DEPT  \nMRCET  CSE DEPT  \nMRCET  CSE DEPT  \n3.  --------------------------------------------------     \ni=1 ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 47
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n43 \n j=1 \nwhile i<=3:  \n    print(\"MRCET\",end=\"  \")  \n    \n    while j<=1:  \n        print (\"CSE DEPT\",end=\"\")  \n        j=j+1  \n    i=i+1  \n           print()  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/wh3.py  \nMRCET  CSE DEPT  \nMRCET   \nMRCET   \n \n4. ----------------------------------------     \n        \n       i = 1 \n       while (i < 10): \n       print (i)  \n    ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 48
    },
    {
        "content": "------------------------     \n        \n       i = 1 \n       while (i < 10): \n       print (i)  \n       i = i+1  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/wh4.py  \n1 \n2 \n3 \n4 \n5 \n6 \n7 \n8 \n9 \n \n2.    ---------------------------------------  \n  a = 1  \n  b = 1  \n  while (a<10):  \n       print ('Iteration',a)  \n       a = a + 1  \n       b = b + 1  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 48
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n44 \n        if (b == 4):  \n            break  \n print ('While loop terminated')  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/wh5.py  \nIteration 1  \nIteration 2  \nIteration 3  \nWhile loop terminated  \n--------------------------  \ncount =  0 \nwhile (count < 9):  \n    print(\"The count is:\", count)  \n    count = count + 1  \nprint(\"Good bye!\")  \n \nOutput:  \nC:/Users/MRCET",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 49
    },
    {
        "content": "nt(\"The count is:\", count)  \n    count = count + 1  \nprint(\"Good bye!\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/wh.py =  \nThe count is: 0  \nThe count is: 1  \nThe count is: 2  \nThe count is: 3  \nThe count is: 4  \nThe count is: 5  \nThe count is: 6  \nThe count is: 7  \nThe count is: 8  \nGood bye!  \n \nFor loop : \nPython  for loop  is used for repeated execution of a group of statements for the desired \nnumber of times.  It iterates over the items of lists, tuples,",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 49
    },
    {
        "content": " group of statements for the desired \nnumber of times.  It iterates over the items of lists, tuples, strings, the dictionaries and other \niterable objects  \nSyntax:   for var in sequence:  \n        Statement(s)                      A sequence of values assigned to  var in each iteration  \nHolds the value of item  \nin sequence in each iteration  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 49
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n45 \n Sample Program : \nnumbers = [1, 2,  4, 6, 11, 20]  \nseq=0  \nfor val in numbers:  \n    seq=val*val  \n    print(seq)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/fr.py  \n1 \n4 \n16 \n36 \n121 \n400 \n \nFlowchart:       \n    \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 50
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n46 \n Iterating over a list:  \n#list of items  \nlist = ['M','R','C','E','T']  \ni = 1 \n \n#Iterating over the list  \nfor item in list:  \n  print ('college ',i,' is ',item)  \n  i = i+1  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/lis.py  \ncollege  1  is  M  \ncollege  2  is  R  \ncollege  3  is  C  \ncollege  4  is  E  \ncollege  5  is  T \n \nIterating over a Tuple:  \ntuple =",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 51
    },
    {
        "content": "  R  \ncollege  3  is  C  \ncollege  4  is  E  \ncollege  5  is  T \n \nIterating over a Tuple:  \ntuple = (2,3,5,7)  \nprint ('These are the first four prime numbers ')  \n#Iterating over the tuple  \nfor a in tuple:  \n  print (a)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fr3.py  \nThese are the first four prime numbers  \n2 \n3 \n5 \n7 \n \nIterating over  a dictionary:  \n#creating a dictionary  \ncollege = {\"ces\":\"block1\",\"it\":\"block2\",\"ece\":\"block3\"}  \n \n#Iterating over the",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 51
    },
    {
        "content": "ating a dictionary  \ncollege = {\"ces\":\"block1\",\"it\":\"block2\",\"ece\":\"block3\"}  \n \n#Iterating over the dictionary to print keys  \nprint ('Keys are:')  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 51
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n47 \n for keys in college:  \n  print (key s) \n \n#Iterating over the dictionary to print values  \nprint ('Values are:')  \nfor blocks in college.values():  \n  print(blocks)  \n  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/dic.py  \nKeys are:  \nces \nit \nece \nValues are:  \nblock1  \nblock2  \nblock3  \n \nIterating over  a String : \n#declare a string to iterate over  \ncollege = '",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 52
    },
    {
        "content": "k1  \nblock2  \nblock3  \n \nIterating over  a String : \n#declare a string to iterate over  \ncollege = 'MRCET'  \n \n#Iterating over the string  \nfor name in college:  \n  print (name)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/strr.py  \nM \nR \nC \nE \nT \n \nNested For loop:  \nWhen one  Loop defined within another Loop is called Nested Loops.  \nSyntax:  \nfor val in sequence:  \nfor val in sequence:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 52
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n48 \n statements  \nstatements  \n \n# Example 1 of Nested For Loops (Pattern Programs)  \nfor i in range(1,6):  \n   for j in range(0,i):  \n      print(i, end=\" \")  \n   print('')  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/nesforr.py  \n1  \n2 2  \n3 3 3  \n4 4 4 4  \n5 5 5 5 5  \n--------------------------  \n# Example 2 of Nested For Loops (Pattern Programs)  \nfor i in range(1,",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 53
    },
    {
        "content": "\n--------------------------  \n# Example 2 of Nested For Loops (Pattern Programs)  \nfor i in range(1,6):  \n   for j in range(5,i -1,-1): \n      print(i, end=\" \")  \n   print('')  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/nesforr.py  \nOutput:  \n1 1 1 1 1  \n2 2 2 2  \n3 3 3  \n4 4  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 53
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n49 \n Break and continue:  \nIn Python, break and continue  statements can alter the flow of a normal loop.  Sometimes \nwe wish to terminate the current iteration or even the whole loop without checking test \nexpression.  The break and continue statements are used in these cases.  \n \nBreak:  \nThe break statement term inates the loop containing it and c ontrol of the progra m flows to \nthe statement i",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 54
    },
    {
        "content": " statement term inates the loop containing it and c ontrol of the progra m flows to \nthe statement immediately after the body of the loop.  If break statement is inside a nested \nloop (loop inside another loop), break will terminate the innermost loop.  \nFlowchart:  \n         \nThe following shows the working of break statement in for and while loop : \nfor var in sequence:  \n # code inside for loop  \nIf condition:  \n break (if break condition satisfies it jumps to outside loop)  \n# code inside fo",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 54
    },
    {
        "content": "  \nIf condition:  \n break (if break condition satisfies it jumps to outside loop)  \n# code inside for loop  \n# code outside for loop  \n \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 54
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n50 \n while test expression  \n# code inside while loop  \nIf condition:  \n break (if break condition satisfies it jumps to outside loop)  \n# code inside while loop  \n# code outside while loop  \n \nExample:  \nfor val in \"MRCET COLLEGE\":  \n    if val == \" \":  \n        break  \n    print(val)  \n \nprint(\"The end\")  \n \nOutput:  \nM \nR \nC \nE \nT \nThe end  \n \n# Program to disp lay all the elements before number",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 55
    },
    {
        "content": " end\")  \n \nOutput:  \nM \nR \nC \nE \nT \nThe end  \n \n# Program to disp lay all the elements before number 88  \n \nfor num in [11, 9, 88, 10, 90, 3, 19]:  \n   print(num)  \n   if(num==88):  \n    print(\"The number 88 is found\")  \n    print(\"Terminating the loop\")  \n    break  \n \nOutput:  \n11 \n9 \n88 \nThe number 88 is found  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 55
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n51 \n Terminating the loop  \n \n#-------------------------------------  \nfor letter in \"Python\": # First Example  \n    if letter == \"h\":  \n        break  \n    print(\"Current Letter :\", letter )  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/br.py =  \nCurrent Letter : P  \nCurrent Letter : y  \nCurrent Letter : t  \nContinue:  \nThe continue statement is used to skip the rest",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 56
    },
    {
        "content": "urrent Letter : y  \nCurrent Letter : t  \nContinue:  \nThe continue statement is used to skip the rest of the code inside a loop for the current \niteration only. Loop does not terminate but continues on with the next iteration.  \nFlowchart:  \n                \nThe following shows the working of break statement in for and while loop : \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 56
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n52 \n for var in sequence:  \n # code inside for loop  \nIf condition:  \n continue (if break condition satisfies it jumps to outside loop)  \n# code inside for loop  \n# code outside for loop  \n \nwhile test ex pression  \n# code inside while loop  \nIf condition:  \n continue(if break condition satisfies it jumps to outside loop)  \n# code inside while loop  \n# code outside while loop  \n \nExample:  \n# Progr",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 57
    },
    {
        "content": "jumps to outside loop)  \n# code inside while loop  \n# code outside while loop  \n \nExample:  \n# Program to show the use of continue statement inside loops  \n \nfor val in \"string\":  \n    if val == \"i\":  \n        continue  \n    print(val)  \n \nprint(\"The end\")  \n \nOutput:  \n \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/cont.py  \ns \nt \nr \nn \ng \nThe end  \n \n# program to display only odd numbers  \n \nfor num in [20, 11, 9, 66, 4, 89, 44]:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 57
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n53 \n     # Skipping the iteration when number is even  \n    if num%2 == 0:  \n        continue  \n    # This statement will be skipped for all even numbers  \n    print(num)  \n \nOutput:  \n \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/cont2.py  \n11 \n9 \n89 \n \n#------------------  \nfor letter in \"Python\": # First Example  \n    if letter == \"h\":  \n        continue  \n    print(\"Current L",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 58
    },
    {
        "content": "etter in \"Python\": # First Example  \n    if letter == \"h\":  \n        continue  \n    print(\"Current Letter :\", letter)  \nOutput:  \n \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/con1.py  \nCurrent Letter : P  \nCurrent Letter : y  \nCurrent Letter : t  \nCurrent Letter : o  \nCurrent Letter : n  \n \nPass:  \n \nIn Python programming,  pass is a null statement. The difference between \na comment  and pass statement in Python is that, while the interpreter ignores a comment \nentirely,  pas",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 58
    },
    {
        "content": "mment  and pass statement in Python is that, while the interpreter ignores a comment \nentirely,  pass is not ignored.  \npass is just a placeholder for  functionality to be added later.  \n \nExample:  \nsequence = {'p', 'a', 's', 's'}  \nfor val in sequence:  \n    pass \n \nOutput:  \n \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/f1.y.py  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 58
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n54 \n >>> \n \nSimilarily we can also write,  \n \ndef f(arg): pass    # a function that does nothing (yet)  \n \nclass C: pass       # a class with no methods (yet)  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 59
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n55 \n UNIT – III \nFUNCTIONS, ARRAYS  \nFruitful functions:  return values, parameters, local and global scope, function composition, \nrecursion; Strings: string slices, immutability, string functions and methods, string module; \nPython arrays, Access the Elements of an Array, ar ray methods.  \nFunctions, Arrays : \nFruitful functions:  \nWe write functions that return values, which we will call  fruitf",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 60
    },
    {
        "content": "s, Arrays : \nFruitful functions:  \nWe write functions that return values, which we will call  fruitful functions . We have seen \nthe return  statement before, but in a fruitful function the  return  statement includes a  return \nvalue . This statement means: \"Return immediately from this function and use the following \nexpression as a return value.\"   \n(or) \nAny function that returns a value is called Fruitful function. A Function that does not return \na value is called a void function  \nReturn ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 60
    },
    {
        "content": "lled Fruitful function. A Function that does not return \na value is called a void function  \nReturn values:  \nThe Keyword return is used to return back the value to the called function.  \n# returns the area of a circle with the given radius:  \ndef area(radius):  \n  temp = 3.14 * radius**2  \n  return temp  \nprint(area(4))  \n \n         (or) \n \ndef area(radius):  \n  return  3.14 * radius**2  \nprint(area(2))  \n \nSometimes it is useful to have multiple return statements, one in each branch of a \ncond",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 60
    },
    {
        "content": "rea(2))  \n \nSometimes it is useful to have multiple return statements, one in each branch of a \nconditional:  \ndef absolute_value(x):  \n    if x < 0:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 60
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n56 \n         return -x \n    else: \n        return x  \nSince these  return  statements are in an alternative conditional, only one will be executed.  \nAs soon as a return statement executes, the function terminates without executing any \nsubsequent statements. Code that appears after a  return  statement, or any other place the \nflow of execution can never reach, is called  dead code.  \nIn a fruitfu",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 61
    },
    {
        "content": "ent, or any other place the \nflow of execution can never reach, is called  dead code.  \nIn a fruitful function, it is a good idea to ensure that every possible path through the program \nhits a  return  statement. For example:  \ndef absolute_value(x):  \n    if x < 0:  \n        return -x \n    if x > 0:  \n        return x  \nThis fu nction is incorrect because if  x happens to be 0, both conditions is true, and the \nfunction ends without hitting a  return  statement. If the flow of execution gets to",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 61
    },
    {
        "content": " true, and the \nfunction ends without hitting a  return  statement. If the flow of execution gets to the end of a \nfunction, the return value is  None, which is not the absolute value of 0.  \n>>> print absolute_value(0)  \nNone  \nBy the way, Python provides a built -in function called  abs that computes absolute values.  \n# Write a Python function that takes two lists and returns True if they have at least one \ncommon member . \ndef common_data(list1, list2):  \n    for x in list1:  \n        for y ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 61
    },
    {
        "content": "at least one \ncommon member . \ndef common_data(list1, list2):  \n    for x in list1:  \n        for y in list2:  \n            if x == y:  \n                result = True  \n                return result  \nprint(common_data([1,2,3,4,5], [1,2,3,4,5]))  \nprint(common_data([1,2,3,4,5], [1,7,8,9,510]))  \nprint(common_data([1,2,3,4,5], [6,7,8 ,9,10]))  \n \nOutput:  \nC:\\Users \\MRCET \\AppData \\Local \\Programs \\Python \\Python38 -32\\pyyy \\fu1.py  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 61
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n57 \n True  \nTrue  \nNone  \n \n#-----------------  \ndef area(radius):  \n    b = 3.14159 * radius**2  \n    return b  \nParameters:  \nParameters are passed during the definition of function while Arguments are passed during \nthe function call . \n \nExample:  \n#here a and b are parameters  \n \ndef add(a,b): #//function definition  \n return a+b  \n  \n#12 and 13 are arguments  \n#function call  \nresult=add(12,1",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 62
    },
    {
        "content": "//function definition  \n return a+b  \n  \n#12 and 13 are arguments  \n#function call  \nresult=add(12,13)  \nprint(result)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/paraarg.py  \n25 \n \nSome examples on functions:  \n# To display vandemataram by using function use no args no return type  \n#function defination  \ndef display():  \n    print(\"vandemataram\")  \nprint(\"i am in mai n\") ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 62
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n58 \n  \n#function call  \ndisplay()  \nprint(\"i am in main\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \ni am in main  \nvandemataram  \ni am in main  \n \n#Type1 : No parameters and no return type  \ndef Fun1() :  \n    print(\"function 1\")  \nFun1()  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nfunction 1  \n#Type 2: with param",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 63
    },
    {
        "content": "sers/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nfunction 1  \n#Type 2: with param with out return type  \ndef fun2(a) :  \n    print(a)  \nfun2(\"hello\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nHello  \n \n#Type 3 : without param with return type  \ndef fun3():  \n    return \"welcome to python\"  \nprint(fun3())  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 63
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n59 \n Output:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nwelcome to python  \n \n#Type 4: with param with return type  \ndef fun4(a):  \n    return a  \nprint(fun4(\"python is better then c\"))  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \npython is better then c  \n \nLocal and Global scope:  \nLocal Scope:  \nA variable which is defined i",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 64
    },
    {
        "content": " \npython is better then c  \n \nLocal and Global scope:  \nLocal Scope:  \nA variable which is defined inside a function is local to that function. It is accessible from \nthe point at which it is defined until the end of the function, and exists for as long as the \nfunction is executing  \nGlobal Scope:  \nA variable which is defined in the main body of a file is called a global variable. It will be \nvisible thro ughout the file, and also inside any file which imports that file.  \n The variable defin",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 64
    },
    {
        "content": "sible thro ughout the file, and also inside any file which imports that file.  \n The variable defined inside a function can also be made global by using the global \nstatement.  \ndef function_name(args):  \n  .............  \n  global x       #declaring global variable inside a function  \n  ............ .. \n# create a global variable  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 64
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n60 \n x = \"global\"  \n \ndef f():  \n    print(\"x inside :\", x)  \n \nf() \nprint(\"x outside:\", x)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nx inside :  global  \nx outside: global  \n \n# create a local variable  \ndef f1 (): \n    y = \"local\"  \n    print(y)  \nf1() \n \nOutput:  \nlocal \n \n If we try to access the local variable outside the scope for example,  \n \ndef ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 65
    },
    {
        "content": "\nOutput:  \nlocal \n \n If we try to access the local variable outside the scope for example,  \n \ndef f2 (): \n    y = \"local\"  \n \nf2() \nprint(y)  \n \nThen when we try to run it shows an error,  \n \nTraceback (most recent call last):  \n  File \"C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py\", line \n6, in <module>  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 65
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n61 \n     print(y)  \nNameError:  name 'y' is not defined  \n \nThe output shows an error, b ecause we are trying to access a local variable  y in a global \nscope whereas the local variable only works inside  f2() or local scope.  \n \n# use local and global variables in same code  \nx = \"global\"  \n \ndef f3():  \n    global x  \n    y = \"local\"  \n    x = x * 2  \n    print(x) \n    print(y)  \n     \nf3() \n \nOu",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 66
    },
    {
        "content": "():  \n    global x  \n    y = \"local\"  \n    x = x * 2  \n    print(x) \n    print(y)  \n     \nf3() \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nglobalglobal  \nlocal  \n \n In the above code, we declare  x as a global and  y as a local variable in the  f3(). Then, \nwe use multiplication operator  * to modify the global variable  x and we print \nboth x and y. \n After calling the  f3(), the value of  x becomes  global global  because we used the  x * \n2 to print ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 66
    },
    {
        "content": "ter calling the  f3(), the value of  x becomes  global global  because we used the  x * \n2 to print two times  global. After that, we print the value of local variable  y i.e local.  \n \n# use Global variable a nd Local variable with same name  \nx = 5  \n \ndef f4():  \n    x = 10  \n    print(\"local x:\", x)  \n \nf4() \nprint(\"global x:\", x)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 66
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n62 \n  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/fu1.py  \nlocal x: 10  \nglobal x: 5  \n \nFunction Composition:  \nHaving  two (or more) functions where the output of one function is the input for another.   So \nfor example if you have two functions FunctionA and FunctionB you compose them by \ndoing the following.  \nFunctionB(FunctionA(x))  \n \nHere x is the input for Fun",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 67
    },
    {
        "content": " you compose them by \ndoing the following.  \nFunctionB(FunctionA(x))  \n \nHere x is the input for FunctionA and the result of that is the input for FunctionB.    \nExample  1: \n#create a function compose2  \n>>> def compose2(f, g):  \n return lambda x:f(g(x))  \n \n>>> def d(x):  \n return x*2  \n \n>>> def e(x):  \n return x+1  \n \n>>> a=compose2(d,e)    # FunctionC = compose(FunctionB,FunctionA)  \n>>> a(5)                         #  FunctionC(x)  \n12 \n \nIn the above program we tried to compose n function",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 67
    },
    {
        "content": "                         #  FunctionC(x)  \n12 \n \nIn the above program we tried to compose n functions  with the main function created.  \nExample 2:  \n>>> colors=('red','green','blue')  \n>>> fruits=['orange','banana','cherry']  \n>>> zip(colors,fruits)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 67
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n63 \n <zip object at 0x03DAC6C8>  \n>>> list(zip(colors,fruits))  \n[('red', 'orange'), ('green', 'banana'), ('blue', 'cherry')]  \nRecursion:  \nRecursion is the process of defining something in terms of itself.  \nPython Recursive Function  \nWe know that in Python, a  function  can call other functions. It is even possible for the \nfunction to call itself. These type of construct are termed as recursiv",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 68
    },
    {
        "content": "It is even possible for the \nfunction to call itself. These type of construct are termed as recursive functions.  \nFactorial of a numbe r is the product of all the integers from 1 to that number. For example, \nthe factorial of 6 (denoted as 6!) is 1*2*3*4*5*6 = 720.  \nFollowing is an example of recursive function to find the factorial of an integer.  \n# Write a program to factorial using recurs ion \ndef fact(x):  \n    if x==0:  \n        result = 1  \n    else :  \n        result = x * fact(x -1) \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 68
    },
    {
        "content": "n \ndef fact(x):  \n    if x==0:  \n        result = 1  \n    else :  \n        result = x * fact(x -1) \n    return result  \nprint(\"zero factorial\",fact(0))  \nprint(\"five factorial\",fact(5))  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/rec.py  \nzero factorial 1  \nfive factorial 120  \n \n----------------------  \ndef calc_factorial(x):  \n    \"\"\"This is a recursive function  \n    to find the factorial of an integer\"\"\"  \n \n    if x == 1:  \n        return 1  \n    else: \n    ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 68
    },
    {
        "content": " \n    to find the factorial of an integer\"\"\"  \n \n    if x == 1:  \n        return 1  \n    else: \n        return (x * calc_factorial(x -1)) ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 68
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n64 \n  \nnum = 4  \nprint( \"The factorial of\", num, \"is\", calc_factorial(num))  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/rec.py  \nThe factorial of 4 is 24  \n \nStrings:  \nA string is a group / a sequence  of characters. Since Python has no provision for arrays, \nwe simply use strings. This is how we declare  a string. We can use a pair of single or \ndouble quotes. Eve",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 69
    },
    {
        "content": "ly use strings. This is how we declare  a string. We can use a pair of single or \ndouble quotes. Every string object is of the type ‘str’.  \n \n>>> type(\"name\")  \n<class 'str'>  \n>>> name=str()  \n>>> name  \n'' \n>>> a=str('mrcet')  \n>>> a  \n'mrcet'  \n>>> a=str(mrcet)  \n>>> a[2]  \n'c' \n>>> fruit = 'banana'  \n>>> letter = fruit[1]  \nThe second statement selects character number 1 from fruit and assigns it to letter. The \nexpression in brackets is called an index. The index indicates which character ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 69
    },
    {
        "content": "s it to letter. The \nexpression in brackets is called an index. The index indicates which character in the \nsequence we want  \n \nString slices:  \nA segment of a string is called a slice. Selecting a slice is similar to selecting a character:  \n \nSubsets of strings can be taken using the slice operator ([ ] and [:])  with indexes starting at 0 \nin the beginning of the string and working their way from -1 at the end.  \nSlice  out substrings, sub lists, sub Tuples using index.   \n \n Syntax: [Start:",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 69
    },
    {
        "content": "rom -1 at the end.  \nSlice  out substrings, sub lists, sub Tuples using index.   \n \n Syntax: [Start: stop: steps]  \n \n Slicing will start from index and will go up to stop in step of steps.  \n Default value of start is 0,  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 69
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n65 \n  Stop is last index of list  \n And for step default is 1  \n \nFor example 1− \nstr = 'Hello World!'   \nprint str    # Prints complete string  \nprint str[0] # Prints first character of the string  \nprint str[2:5] # Prints characters starting from 3rd to 5th  \nprint str[2:] # Prints string starting from 3rd character print  \nstr * 2 # Prints string two times  \nprint str + \"TEST\" # Prints concate",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 70
    },
    {
        "content": "g from 3rd character print  \nstr * 2 # Prints string two times  \nprint str + \"TEST\" # Prints concatenated string  \nOutput:  \nHello World!  \nH  \nllo  \nllo World!  \nHello  World!Hello World!  \nHello World!TEST  \nExample  2: \n>>> x='computer'  \n>>> x[1:4]  \n'omp'  \n>>> x[1:6:2]  \n'opt' \n>>> x[3:]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 70
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n66 \n 'puter'  \n>>> x[:5]  \n'compu'  \n>>> x[ -1] \n'r' \n>>> x[ -3:] \n'ter' \n>>> x[: -2] \n'comput'  \n>>> x[:: -2] \n'rtpo'  \n>>> x[:: -1] \n'retupmoc'  \n \nImmutability:  \nIt is tempting to use the [] operator on the left side of an assignment, with the intention of \nchanging a character in a string.  \nFor example:  \n \n>>> greeting='mrcet college!'  \n>>> greeting[0]='n'  \n \nTypeError: 'str' object does n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 71
    },
    {
        "content": " example:  \n \n>>> greeting='mrcet college!'  \n>>> greeting[0]='n'  \n \nTypeError: 'str' object does not support item assignment  \n \nThe reason for the error is that strings are immutable , which means we can’t change an \nexisting string. The best we can do is creating  a new string that is a variation on the original:  \n \n>>> greeting = 'Hello, world!'  \n>>> new_greeting = 'J' + greeting[1:]  \n>>> new_greeting  \n'Jello, world!'  \n \nNote: The plus (+) sign is the string concatenation operator and ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 71
    },
    {
        "content": "new_greeting  \n'Jello, world!'  \n \nNote: The plus (+) sign is the string concatenation operator and the asterisk (*) is the \nrepetition operator   ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 71
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n67 \n  \nString functions and methods:  \n \nThere are many methods  to operate on String.   \n \nS.no Method name  Description  \n1. isalnum()  Returns true if string has at least 1 character and all  \ncharacters are alphanumeric and false otherwise.  \n2. isalpha()  Returns true if string has at least 1 character and all  \ncharacters are alphabetic and false otherwise.  \n3. isdigit()  Returns true if str",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 72
    },
    {
        "content": "aracter and all  \ncharacters are alphabetic and false otherwise.  \n3. isdigit()  Returns true if string contains only digits and false  \notherwise.  \n4. islower()  Returns true if string has at least 1 cased character and all cased \ncharacters are in lowercase and false  \notherwise.  \n5. isnumeric()  Returns true if a string contains only numeric  \ncharacters and false otherwise.  \n6. isspace()  Returns true if string contains only whitespace  \ncharacters and false otherwise.  \n7. istitle()  Ret",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 72
    },
    {
        "content": "eturns true if string contains only whitespace  \ncharacters and false otherwise.  \n7. istitle()  Returns true if string is properly “titlecased” and  \nfalse otherwise.  \n8. isupper()  Returns true if string has at least one cased character and all \ncased characters are in uppercase  \nand false otherwise.  \n9. replace(old, new \n[, max])  Replaces all occurrences of old in string with new  \nor at most max occurrences if max given.  \n10. split()  Splits string according to delimiter str (space if n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 72
    },
    {
        "content": "st max occurrences if max given.  \n10. split()  Splits string according to delimiter str (space if not  \nprovided) and returns list of substrings;  \n11. count()  Occurrence of a string in another string  \n12. find()  Finding the index of the first occurrence of a string  \nin another string  \n13. swapcase()  Converts lowercase letters in a string to uppercase  \nand viceversa  \n14. startswith(str, \nbeg=0,end=le\nn(string))  Determines if string or a substring of string (if starting index \nbeg and e",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 72
    },
    {
        "content": "beg=0,end=le\nn(string))  Determines if string or a substring of string (if starting index \nbeg and ending index end are given) starts with substring str; \nreturns true if so and false  \notherwise.  \n \nNote:  \nAll the string methods will be returning either true or false as the result  \n \n1. isalnum():  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 72
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n68 \n Isalnum() method returns true if string has at least 1 character and all characters are \nalphanumeric and false otherwise.  \n \nSyntax:  \nString.isalnum()  \n \nExample:  \n>>> string=\"123alpha\"  \n>>> string.isalnum() True  \n \n2. isalpha():  \nisalpha() method returns true if string has at least 1 character and all characters are \nalphabetic and false otherwise.  \n \nSyntax:  \nString.isalpha()  \n \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 73
    },
    {
        "content": "aracter and all characters are \nalphabetic and false otherwise.  \n \nSyntax:  \nString.isalpha()  \n \n Example:  \n>>> string=\"nikhil\"  \n>>> string.isalpha()  \nTrue  \n \n3. isdigit():  \nisdigit() returns true if string contains only digits and false otherwise.  \n \nSyntax:  \nString.isdigit()  \n \nExample:  \n>>> string=\"123456789\"  \n>>> string.isdigit()  \nTrue  \n \n4. islower():  \nIslower() returns true if string has characters that are in lower case and false otherwise.  \n \nSyntax:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 73
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n69 \n String.islower()  \n \nExample:  \n>>> string=\"nikhil\"  \n>>> string.islower()  \nTrue  \n \n5. isnumeric():  \nisnumeric() method returns true if a string contains only numeric characters and false \notherwise.  \n \nSyntax:  \nString.isnumeric()  \n  \nExample:  \n>>> string=\"123456789\"  \n>>> string.isnumeric()  \nTrue  \n \n6. isspace():  \nisspace() returns true if string contains only whitespace characters ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 74
    },
    {
        "content": "c()  \nTrue  \n \n6. isspace():  \nisspace() returns true if string contains only whitespace characters and false otherwise.  \n \nSyntax:  \nString.isspace()  \n \nExample:  \n>>> string=\" \"  \n>>> string.isspace()  \nTrue  \n \n7. istitle()  \nistitle() method returns true if string is properly “titlecased”(starting letter of each word is \ncapital) and false otherwise  \n \nSyntax:  \nString.istitle()  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 74
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n70 \n Example:  \n>>> string=\"Nikhil Is Learning\"  \n>>> string.istitle()  \nTrue  \n \n8. isupper()  \nisupper() returns true if string has characters that are in uppercase and false otherwise.  \n \nSyntax:  \nString.isupper()  \n \nExample:  \n>>> string=\"HELLO\"  \n>>> string.isupper()  \nTrue  \n \n9. replace()  \nreplace() method replaces all occurrences of old in string with new or at most max \noccurrences  if",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 75
    },
    {
        "content": "\nreplace() method replaces all occurrences of old in string with new or at most max \noccurrences  if max given.  \n \nSyntax:  \nString.replace()  \n \nExample:  \n>>> string=\"Nikhil Is Learning\"  \n>>> string.replace('Nikhil','Neha')  \n 'Neha Is Learning'  \n \n10. split()  \nsplit() method splits the string according to delimiter str (space if not provided)  \n \nSyntax:  \nString.split()  \n \nExample:  \n>>> string=\"Nikhil Is Learning\"  \n>>> string.split()  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 75
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n71 \n  ['Nikhil', 'Is', 'Learning']  \n \n11. count()  \ncount() method counts the occurrence of a string in another string Syntax:  \nString.count()  \n \n Example:  \n>>> string='Nikhil Is Learning'  \n>>> string.count('i')  \n3 \n \n12. find()  \nFind() method is used for finding the index of the first occurrence of a string in another \nstring  \n \nSyntax:  \nString.find(„string‟)  \n \nExample:  \n>>> string=\"Ni",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 76
    },
    {
        "content": "nce of a string in another \nstring  \n \nSyntax:  \nString.find(„string‟)  \n \nExample:  \n>>> string=\"Nikhil Is Learning\"  \n>>> string.find('k')  \n 2 \n13. swapcase()  \nconverts lowercase letters in a string to uppercase and viceversa  \n \nSyntax:  \nString.find(„string‟)  \n \nExample:  \n>>> string=\"HELLO\"  \n>>> string.swapcase()  \n 'hello'  \n \n14. startswith()  \nDetermines if string or a substring of string (if starting index beg and ending index end are \ngiven) starts with substring str; returns true ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 76
    },
    {
        "content": "ing (if starting index beg and ending index end are \ngiven) starts with substring str; returns true if so and false otherwise.  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 76
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n72 \n Syntax:  \nString.startswith(„string‟)  \n \nExample:  \n>>> string=\"Nikhil Is Learning\"  \n>>> string.startswith('N')  \nTrue  \n \n15. endswith()  \nDetermines if string or a substring of string (if starting index beg and ending index end are \ngiven) ends with substring str; returns true if so and false otherwise.  \n \nSyntax:  \nString.endswith(„string‟)  \n \n Example:  \n>>> string=\"Nikhil Is Learning\"",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 77
    },
    {
        "content": "e otherwise.  \n \nSyntax:  \nString.endswith(„string‟)  \n \n Example:  \n>>> string=\"Nikhil Is Learning\"  \n>>> string.startswith('g')  \nTrue  \n \nString module:  \n \nThis module contains a number of functions to process standard Python strings. In recent \nversions, most functions are available as string methods as well.  \n \nIt’s a built -in module and we have to import  it before using any of its constants and classes  \n \nSyntax: import string  \n \nNote:  \nhelp(string)  --- gives the information abo ut",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 77
    },
    {
        "content": "nts and classes  \n \nSyntax: import string  \n \nNote:  \nhelp(string)  --- gives the information abo ut all the variables ,functions, attributes and classes \nto be used in string module.  \n \nExample:  \nimport string  \nprint(string.ascii_letters)  \nprint(string.ascii_lowercase)  \nprint(string.ascii_uppercase)  \nprint(string.digits)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 77
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n73 \n print(string.hexdigits)  \n#print(string.whitespace)   \nprint(string.punctuation)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/strrmodl.py \n=========================================  \nabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ  \nabcdefghijklmnopqrstuvwxyz  \nABCDEFGHIJKLMNOPQRSTUVWXYZ  \n0123456789  \n0123456789abcdefABCDEF  \n!\"#$%&'()*+, -./:;<=>?@[ \\]^_`",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 78
    },
    {
        "content": "  \nABCDEFGHIJKLMNOPQRSTUVWXYZ  \n0123456789  \n0123456789abcdefABCDEF  \n!\"#$%&'()*+, -./:;<=>?@[ \\]^_`{|}~  \n \nPython String Module Classes  \nPython string module contains two classes – Formatter and Template.  \nFormatter  \nIt behaves exactly same as  str.format()  function. This class becomes useful if you want to \nsubclass it and define your own format string syntax.  \nSyntax: from string import Formatter  \nTemplate  \nThis class is used to create a string template for simpler string substitution",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 78
    },
    {
        "content": "ormatter  \nTemplate  \nThis class is used to create a string template for simpler string substitutions  \nSyntax: from string import Template  \nPython arrays:  \nArray is a container which can hold a fix number of items and these items should be of the \nsame type. Most of the data structures make use of arrays to implement their algorithms. \nFollowing are the important terms to understand the concept of Array.  \n Element − Each item stored in an array is called an element.  \n Index  − Each locati",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 78
    },
    {
        "content": " of Array.  \n Element − Each item stored in an array is called an element.  \n Index  − Each location of an element in  an array has a numerical index, which is used \nto identify the element.  \nArray Representation  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 78
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n74 \n Arrays can be declared in various ways in different languages. Below is an illustration.  \nElements  \nInt array [10] = {10, 20, 30, 40, 50, 60, 70, 80, 85, 90}  \n \nType  Name Size      Index 0   \n \nAs per the above illustration, following are the important points to be considered.  \n Index starts with 0.  \n Array length is 10 which means it can store 10 elements.  \n Each element can be acce",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 79
    },
    {
        "content": "ts with 0.  \n Array length is 10 which means it can store 10 elements.  \n Each element can be accessed via its index. For example, we can fetch an element at \nindex 6 as 70  \nBasic Operations  \nFollowing are the basic operations supported by an array.  \n Traverse  − print all the array elements one by one.  \n Insertion  − Adds an element at the given index.  \n Deletion  − Deletes an element at the given index.  \n Search  − Searches an element using the given index or by the value.  \n Upda",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 79
    },
    {
        "content": "t the given index.  \n Search  − Searches an element using the given index or by the value.  \n Update  − Updates an element at the given index.  \nArray is created in Python by importing array module to the python program. Then the \narray is declared as shown below. \nfrom array import *  \narrayName=array(typecode, [initializers])  \nTypecode are the codes that are used to define the type of value the array will hold. Some \ncommon typecodes used are:  \n \nTypecode  Value  \nb Represents signed integ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 79
    },
    {
        "content": "he array will hold. Some \ncommon typecodes used are:  \n \nTypecode  Value  \nb Represents signed integer of size 1 byte/td>  \nB Represents unsigned integer of size 1 byte  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 79
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n75 \n c Represents character of size 1 byte  \ni Represents signed integer of size 2 bytes  \nI Represents unsigned integer of size 2 bytes  \nf Represents floating point of size 4 bytes  \nd Represents floating point of size 8 bytes  \n \nCreating an array:  \nfrom array import *  \narray1 = array('i', [10,20,30,40,50])  \nfor x in array1:  \n print(x)  \n \nOutput:  \n>>>  \n RESTART: C:/Users/MRCET/AppData/Loc",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 80
    },
    {
        "content": "0,30,40,50])  \nfor x in array1:  \n print(x)  \n \nOutput:  \n>>>  \n RESTART: C:/Users/MRCET/AppData/Local/Progra ms/Python/Python38 -32/arr.py  \n10 \n20 \n30 \n40 \n50 \n \nAccess the element s of an A rray:  \nAccessing Array Element  \nWe can access each element of an array using the index of the element.  \nfrom array import *  \narray1 = array('i', [10,20,30,40,50])  \nprint (array1[0])  \nprint (array1[2])  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 80
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n76 \n Output:  \nRESTART: C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/arr2.py  \n10 \n30 \n \nArray methods:  \nPython has a set of built -in methods that you can use on lists/arrays.  \nMethod  Description  \nappend()  Adds an element at the end of the list  \nclear()  Removes all the elements from the list  \ncopy()  Returns a copy of the list  \ncount()  Returns the number of elements wit",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 81
    },
    {
        "content": "nts from the list  \ncopy()  Returns a copy of the list  \ncount()  Returns the number of elements with the specified value  \nextend()  Add the elements of a list (or any iterable), to the end of the current list  \nindex()  Returns the index of the first element with the specified value  \ninsert()  Adds an element at the specified position  \npop()  Removes the element at the specified position  \nremove()  Removes the first item with the specified value  \nreverse()  Reverses the order of the list  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 81
    },
    {
        "content": "ove()  Removes the first item with the specified value  \nreverse()  Reverses the order of the list  \nsort()  Sorts the list  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 81
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n77 \n  \nNote:  Python does not have built -in support for Arrays, but Python Lists can be used instead.  \nExample:  \n>>> college=[\"mrcet\",\"it\",\"cse\"]  \n>>> college.append(\"autonomous\")  \n>>> college  \n['mrcet', 'it', 'cse', 'autonomous']  \n>>> college.append(\"eee\")  \n>>> college.append(\"ece\")  \n>>> college  \n['mrcet', 'it', 'cse', 'autonomous', 'eee', 'ece']  \n>>> college.pop()  \n'ece' \n>>> college ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 82
    },
    {
        "content": "llege  \n['mrcet', 'it', 'cse', 'autonomous', 'eee', 'ece']  \n>>> college.pop()  \n'ece' \n>>> college  \n['mrcet', 'it', 'cse', 'autonomous', 'eee']  \n>>> college.pop(4)  \n'eee' \n>>> college  \n['mrcet', 'it', 'cse', 'autonomous']  \n>>> college.remove(\"it\")  \n>>> college  \n['mrcet', 'cse', 'autonomous']  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 82
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n78 \n UNIT – IV \nLISTS, TUPLES, DICTIONARIES  \nLists:  list operations, list slices, list methods, list loop, mutability, aliasing, cloning lists, list \nparameters, list comprehension; Tuples: tuple assignment, tuple as return value, tuple \ncomprehension; Dictionaries : operations and methods,  comprehension;  \nLists, Tuples, Dictionaries : \nList:  \n It is a general purpose most widely used in data",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 83
    },
    {
        "content": "hension;  \nLists, Tuples, Dictionaries : \nList:  \n It is a general purpose most widely used in data structures  \n List is a collection which is ordered and changeable and allows duplicate members. \n(Grow and shrink as needed, sequence type,  sortable).  \n To use a list, you must declare it first. Do this using square brackets and separate \nvalues with commas.  \n We can construct / create list in many ways.  \nEx:  \n>>> list1=[1,2,3,'A','B',7,8,[10,11]]  \n>>> print(list1)  \n[1, 2, 3, 'A', 'B',",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 83
    },
    {
        "content": "in many ways.  \nEx:  \n>>> list1=[1,2,3,'A','B',7,8,[10,11]]  \n>>> print(list1)  \n[1, 2, 3, 'A', 'B', 7, 8, [10, 11]]  \n----------------------  \n>>> x=list()  \n>>> x  \n[] \n--------------------------  \n>>> tuple1=(1,2,3,4)  \n>>> x=list(tuple1)  \n>>> x  \n[1, 2, 3, 4]  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 83
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n79 \n List operations:  \nThese operations include indexing, slicing, adding, multiplying, and checking for \nmembership  \nBasic List Operations : \nLists respond to the + and * operators much like strings; they mean concatenation and \nrepetition here too, except that the result is a new list, not a string.  \nPython Expression  Results  Description  \nlen([1, 2, 3])  3 Length  \n[1, 2, 3] + [4, 5, 6]  [1",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 84
    },
    {
        "content": "ng.  \nPython Expression  Results  Description  \nlen([1, 2, 3])  3 Length  \n[1, 2, 3] + [4, 5, 6]  [1, 2, 3, 4, 5, 6]  Concatenation  \n['Hi!'] * 4  ['Hi!', 'Hi!', 'Hi!', 'Hi!']  Repetition  \n3 in [1, 2, 3]  True  Membership  \nfor x in [1, 2, 3]: print x,  1 2 3  Iteration  \nIndexing, Slicing, and Matrixes  \nBecause lists are sequences, indexing  and slicing work the same way for lists as they do for \nstrings.  \nAssuming following input −  \nL = [' mrcet ', 'college ', 'MRCET !'] \n \nPython Expressi",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 84
    },
    {
        "content": "r \nstrings.  \nAssuming following input −  \nL = [' mrcet ', 'college ', 'MRCET !'] \n \nPython Expression  Results  Description  \nL[2] MRCET  Offsets start at zero  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 84
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n80 \n L[-2] college  Negative: count from the right  \nL[1:]  ['college ', 'MRCET !'] Slicing fetches sections  \n \nList slices:  \n>>> list1=range(1,6)  \n>>> list1  \nrange(1, 6)  \n>>> print(list1)  \nrange(1, 6)  \n>>> list1=[1,2,3,4,5,6,7,8,9,10]  \n>>> list1[1:]  \n[2, 3, 4, 5, 6, 7, 8, 9, 10]  \n>>> list1[:1]  \n[1] \n>>> list1[2:5]  \n[3, 4, 5]  \n>>> list1[:6]  \n[1, 2, 3, 4, 5, 6]  \n>>> list1[1:2:4]  \n[2]",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 85
    },
    {
        "content": "[:1]  \n[1] \n>>> list1[2:5]  \n[3, 4, 5]  \n>>> list1[:6]  \n[1, 2, 3, 4, 5, 6]  \n>>> list1[1:2:4]  \n[2] \n>>> list1[1:8:2]  \n[2, 4, 6, 8]  \nList methods :  \nThe list data type has some more methods. Here are all of the methods of list objects:  \n Del()  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 85
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n81 \n  Append()  \n Extend()  \n Insert()  \n Pop()  \n Remove()  \n Reverse()  \n Sort()  \nDelete:  Delete a list or an item from a list  \n>>> x=[5,3,8,6]  \n>>> del(x[1])              #deletes the index position 1 in a list  \n>>> x  \n[5, 8, 6]  \n------------  \n>>> del(x)  \n>>> x                       # complete list gets deleted  \nAppend:  Append an item to a list  \n>>> x=[1,5,8,4]  \n>>> x.append(",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 86
    },
    {
        "content": "  # complete list gets deleted  \nAppend:  Append an item to a list  \n>>> x=[1,5,8,4]  \n>>> x.append(10)  \n>>> x  \n[1, 5, 8, 4, 10]  \nExtend: Append a sequence to a list.  \n>>> x=[1,2,3,4]  \n>>> y=[3,6,9,1]  \n>>> x.extend(y)  \n>>> x  \n[1, 2, 3, 4, 3, 6, 9, 1]  \nInsert:  To add an item at the specified index, use the  insert ()  method:  \n>>> x=[1,2,4,6, 7] ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 86
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n82 \n >>> x.insert(2,10)    #insert(index no, item to be inserted)  \n>>> x  \n[1, 2, 10, 4, 6, 7]  \n-------------------------  \n>>> x.insert(4,['a',11])  \n>>> x  \n[1, 2, 10, 4, ['a', 11], 6, 7]  \nPop:  The pop()  method removes the specified index, (or the last item if index i s not \nspecified)  or simply p ops the last item of list and returns the item . \n>>> x=[1, 2, 10, 4, 6, 7]  \n>>> x.pop()  \n7 ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 87
    },
    {
        "content": "ply p ops the last item of list and returns the item . \n>>> x=[1, 2, 10, 4, 6, 7]  \n>>> x.pop()  \n7 \n>>> x  \n[1, 2, 10, 4, 6]  \n-----------------------------------  \n>>> x=[1, 2, 10, 4, 6]  \n>>> x.pop(2)  \n10 \n>>> x  \n[1, 2, 4, 6]  \nRemove:  The remove()  method removes the specified item  from a given list.  \n>>> x=[1,33,2,10,4,6]  \n>>> x.remove(33)  \n>>> x  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 87
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n83 \n [1, 2, 10, 4, 6]  \n>>> x.remove(4)  \n>>> x  \n[1, 2, 10, 6]  \nReverse: Reverse the order of a given list.  \n>>> x=[1,2,3,4,5,6,7]  \n>>> x.reverse()  \n>>> x  \n[7, 6, 5, 4, 3, 2, 1] \nSort: Sorts the elements in ascending order  \n>>> x=[7, 6, 5, 4, 3, 2, 1]  \n>>> x.sort()  \n>>> x  \n[1, 2, 3, 4, 5, 6, 7]  \n-----------------------  \n>>> x=[10,1,5,3,8,7]  \n>>> x.sort()  \n>>> x  \n[1, 3, 5, 7, 8, 10]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 88
    },
    {
        "content": ", 7]  \n-----------------------  \n>>> x=[10,1,5,3,8,7]  \n>>> x.sort()  \n>>> x  \n[1, 3, 5, 7, 8, 10]  \nList loop:  \nLoops  are control structures used to repeat a given section of code a certain number of times \nor until a particular condition is met.  \nMethod #1:  For loop  \n#list of items  \nlist = ['M','R','C','E','T']  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 88
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n84 \n i = 1 \n \n#Iterating over the list  \nfor item in list:  \n  print ('college ',i,' is ',item)  \n  i = i+1  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/lis.py  \ncollege  1  is  M  \ncollege  2  is  R  \ncollege  3  is  C  \ncollege  4  is  E  \ncollege  5  is  T  \n \nMethod #2:  For loop and range()  \nIn case we want to use the traditional for loop which iterates from numb",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 89
    },
    {
        "content": "#2:  For loop and range()  \nIn case we want to use the traditional for loop which iterates from number x to number y.  \n# Python3 code to iterate over a list  \nlist = [1, 3, 5, 7, 9]  \n    \n# getting length of list  \nlength = len(list)  \n    \n# Iterating the index  \n# same as 'for i in range(len(list))'  \nfor i in range(length):  \n    print(list[i])  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/listlooop.py  \n1 \n3 \n5 \n7 \n9 \nMethod #3 : using while loop  \n \n# Python",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 89
    },
    {
        "content": "ams/Python/Python38 -32/pyyy/listlooop.py  \n1 \n3 \n5 \n7 \n9 \nMethod #3 : using while loop  \n \n# Python3 code to iterate over a list  \nlist = [1, 3, 5, 7, 9]  \n    \n# Getting length of list  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 89
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n85 \n length = len(list)  \ni = 0 \n    \n# Iterating using while loop  \nwhile i < length:  \n    print(list[i])  \n    i += 1  \n \nMutability : \n A mutable  object can be changed after it is created, and an immutable object can't.   \nAppend:  Append an item to a list  \n>>> x=[1,5,8,4]  \n>>> x.append(10)  \n>>> x  \n[1, 5, 8, 4, 10]  \nExtend: Append a sequence to a list.  \n>>> x=[1,2,3,4]  \n>>> y=[3,6,9,1] ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 90
    },
    {
        "content": ">>> x  \n[1, 5, 8, 4, 10]  \nExtend: Append a sequence to a list.  \n>>> x=[1,2,3,4]  \n>>> y=[3,6,9,1]  \n>>> x.extend(y)  \n>>> x  \nDelete:  Delete a list or an item from a list  \n>>> x=[5,3,8,6]  \n>>> del(x[1])              #deletes the index position 1 in a list  \n>>> x  \n[5, 8, 6]  \nInsert:  To add an item at the specified index, use the  insert ()  method:  \n>>> x=[1,2,4,6,7]  \n>>> x.insert(2,10)    #insert(index no, item to be inserted)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 90
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n86 \n >>> x  \n[1, 2, 10, 4, 6, 7]  \n-------------------------  \n>>> x.insert(4,['a',11])  \n>>> x  \n[1, 2, 10, 4, ['a', 11], 6, 7]  \nPop:  The pop()  method removes the specified index, (or the last item if index is not \nspecified)  or simply p ops the last item of list and returns the item . \n>>> x=[1, 2, 10, 4, 6, 7]  \n>>> x.pop()  \n7 \n>>> x  \n[1, 2, 10, 4, 6]  \n----------------------------------- ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 91
    },
    {
        "content": ", 2, 10, 4, 6, 7]  \n>>> x.pop()  \n7 \n>>> x  \n[1, 2, 10, 4, 6]  \n-----------------------------------  \n>>> x=[1, 2, 10, 4, 6]  \n>>> x.pop(2)  \n10 \n>>> x  \n[1, 2, 4, 6]  \nRemove:  The remove()  method removes the specified item  from a given list.  \n>>> x=[1,33,2,10,4,6]  \n>>> x.remove(33)  \n>>> x  \n[1, 2, 10, 4, 6]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 91
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n87 \n >>> x.remove(4)  \n>>> x  \n[1, 2, 10, 6]  \nReverse: Reverse the order of a given list.  \n>>> x=[1,2,3,4,5,6,7]  \n>>> x.reverse()  \n>>> x  \n[7, 6, 5, 4, 3, 2, 1]  \nSort:  Sorts the elements in ascending order  \n>>> x=[7, 6, 5, 4, 3, 2, 1]  \n>>> x.sort()  \n>>> x  \n[1, 2, 3, 4, 5, 6, 7]  \n-----------------------  \n>>> x=[10,1,5,3,8,7]  \n>>> x.sort()  \n>>> x  \n[1, 3, 5, 7, 8, 10]  \n \nAliasing:  \n1.",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 92
    },
    {
        "content": "-------------  \n>>> x=[10,1,5,3,8,7]  \n>>> x.sort()  \n>>> x  \n[1, 3, 5, 7, 8, 10]  \n \nAliasing:  \n1. An alias is a second name for a piece of data, often easier (and more useful) than \nmaking a copy.  \n2. If the data is immutable, aliases don’t matter because the data can’t change.  \n3. But if data can change, aliases can result in lot of hard – to – find bugs.  \n4. Aliasing happens whenever one variable’s value is assigned to another variable.  \n \nFor ex:  \na = [81, 82, 83]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 92
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n88 \n b = [81, 82, 83]  \nprint(a == b)  \nprint(a is b)  \nb = a  \nprint(a == b)  \nprint(a is b)  \nb[0] = 5  \nprint(a)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/alia.py  \nTrue  \nFalse  \nTrue  \nTrue  \n[5, 82, 83]  \n \nBecause the same list has two different names,  a and b, we say that it is  aliased . Changes \nmade with one alias affect the other. In the example above ,",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 93
    },
    {
        "content": ", we say that it is  aliased . Changes \nmade with one alias affect the other. In the example above , you can see that  a and b refer to \nthe same list after executing the assignment statement  b = a. \nCloning Lists:  \nIf we want to modify a list and also keep a copy of the original, we need t o be able to make a \ncopy of the list itself, not just the reference. This process is sometimes called  cloning , to \navoid the ambiguity of the word copy.  \nThe easiest way to clone a list is to use the sl",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 93
    },
    {
        "content": "oning , to \navoid the ambiguity of the word copy.  \nThe easiest way to clone a list is to use the slice operator.  Taking any slice of  a creates a new \nlist. In this case the slice happens to consist of the whole list.  \nExample:  \na = [81, 82, 83]  \nb = a[:]       # make a clone using slice  \nprint(a == b)  \nprint(a is b)  \nb[0] = 5  \nprint(a)  \nprint(b)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 93
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n89 \n Output:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/clo.py  \nTrue  \nFalse  \n[81, 82, 83]  \n[5, 82, 83]  \nNow we are free to make changes to  b without worrying about  a \n \nList parameters:  \nPassing a list as an argument actually passes a reference to the list, not a copy of the list. \nSince lists are mutable, changes made to the elements referenced by the parameter change",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 94
    },
    {
        "content": " the list. \nSince lists are mutable, changes made to the elements referenced by the parameter change \nthe same list that the argument is referencing.  \n# for example, the function below takes a list as an argument and multiplies each element in \nthe list by 2:  \ndef doubleStuff(List):  \n    \"\"\" Overwrite each element in aList with double its value. \"\"\"  \n    for position in range(len(List)):  \n        List[position] = 2 * List[position]  \n \nthings = [2, 5, 9]  \nprint(things)  \ndoubleStuff(things",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 94
    },
    {
        "content": "     List[position] = 2 * List[position]  \n \nthings = [2, 5, 9]  \nprint(things)  \ndoubleStuff(things)  \nprint(things)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/lipar.py ==  \n[2, 5, 9]  \n[4, 10, 18]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 94
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n90 \n  \nList comprehension:  \nList:  \nList comprehensions provide a concise way to create lists. Common applications are to make \nnew lists where each element is the result of some operations applied to each member of \nanother sequence or iterable, or to create a subsequence of those elements that satisfy a \ncertain condition.  \nFor example, assume we want to create a list of squares, like:  \n>>> li",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 95
    },
    {
        "content": "isfy a \ncertain condition.  \nFor example, assume we want to create a list of squares, like:  \n>>> list1=[]  \n>>> for x in range(10):  \n list1.append(x**2)  \n>>> list1  \n[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  \n(or) \nThis is also equivalent to  \n>>> list1=list(map(lambda x:x**2, range(10)))  \n>>> list1  \n[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  \n(or) \nWhich is more concise and redable.  \n>>> list1=[x* *2 for x in range(10)]  \n>>> list1  \n[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 95
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n91 \n Similarily some examples:  \n \n>>> x=[m for m in range(8)]  \n>>> print(x)  \n[0, 1, 2, 3, 4, 5, 6, 7]  \n \n>>> x=[z**2 for z in range(10) if z>4]  \n>>> print(x)  \n[25, 36, 49, 64, 81]  \n \n>>> x=[x ** 2  for  x in range (1, 11)   if  x % 2 == 1]  \n>>> print(x)  \n[1, 9, 25, 49, 81]  \n \n>>> a=5  \n>>> table = [[a, b, a * b] for b in range(1, 11)]  \n>>> for i in table:  \n print(i)  \n \n  \n[5, 1, 5]  \n[",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 96
    },
    {
        "content": "table = [[a, b, a * b] for b in range(1, 11)]  \n>>> for i in table:  \n print(i)  \n \n  \n[5, 1, 5]  \n[5, 2, 10]  \n[5, 3, 15]  \n[5, 4, 20]  \n[5, 5, 25]  \n[5, 6, 30]  \n[5, 7, 35]  \n[5, 8, 40]  \n[5, 9, 45] \n[5, 10, 50]  \n \nTuples:  \nA tuple is a collection which is ordered and  unchangeable. In Python tuples are written \nwith round brackets.  \n Supports all operations for sequences.  \n Immutable, but member objects may be mutable.  \n If the contents of a list shouldn’t change, use a tuple to preve",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 96
    },
    {
        "content": " member objects may be mutable.  \n If the contents of a list shouldn’t change, use a tuple to prevent items from ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 96
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n92 \n accidently being added, changed, or deleted.  \n Tuples are more efficient than list due to python’s implementation.  \n  \nWe can construct tuple in many ways:  \nX=()     #no item tuple  \nX=(1,2,3)  \nX=tuple(list1)  \nX=1,2,3,4  \n \nExample:  \n>>> x=(1,2,3)  \n>>> print(x)  \n(1, 2, 3)  \n>>> x  \n(1, 2, 3)  \n-----------------------  \n>>> x=()  \n>>> x  \n() \n----------------------------  \n>>> x=[4,5,6",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 97
    },
    {
        "content": "2, 3)  \n-----------------------  \n>>> x=()  \n>>> x  \n() \n----------------------------  \n>>> x=[4,5,66,9]  \n>>> y=tuple(x)  \n>>> y  \n(4, 5, 66, 9)  \n-----------------------------  \n>>> x=1,2,3,4  \n>>> x  \n(1, 2, 3, 4)  \n \nSome of the operations of tuple are:  \n Access tuple items  \n Change tuple items  \n Loop through a tuple  \n Count()  \n Index()  \n Length()  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 97
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n93 \n  \nAccess tuple items:  Access tuple items by referring to the index number, inside square \nbrackets   \n>>> x=('a','b','c','g')  \n>>> print(x[2])  \nc \nChange tuple items:  Once a tuple is created, you cannot change its values. Tuples \nare unchangeable.  \n \n>>> x=(2,5,7,'4',8)  \n>>> x[1]=10  \nTraceback (most recent call last):  \n  File \"<pyshell#41>\", line 1, in <module>  \n    x[1]=10  \nTypeErro",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 98
    },
    {
        "content": "eback (most recent call last):  \n  File \"<pyshell#41>\", line 1, in <module>  \n    x[1]=10  \nTypeError: 'tuple' object does not support item assignment  \n>>> x  \n(2, 5, 7, '4', 8)     # the value is still the same  \n \nLoop through a tuple:  We can loop the values of tuple using for loop  \n>>> x=4,5,6,7,2,'aa'  \n>>> for i in x:  \n print(i)  \n \n  \n4 \n5 \n6 \n7 \n2 \naa \n \nCount  (): Returns the number of times a specified value occurs in a tuple  \n>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)  \n>>> x.count(2)  \n4",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 98
    },
    {
        "content": " times a specified value occurs in a tuple  \n>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)  \n>>> x.count(2)  \n4 \n \nIndex ():  Searches the tuple for a specified  value and returns the position o f where it       \n                 was found  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 98
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n94 \n >>> x=(1,2,3,4,5,6,2,10,2,11,12,2)  \n>>> x.index(2)  \n1 \n \n(Or) \n \n>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)  \n>>> y=x.index(2)  \n>>> print(y)  \n1 \n \nLength ():  To know the number of items or values present in a tuple, we use len().  \n>>> x=(1,2,3,4,5,6,2,10,2,11,12,2)  \n>>> y=len(x ) \n>>> print(y)  \n12 \n \nTuple  Assignment  \nPython  has tuple  assignment  feature  which  enables  you to assign  mor",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 99
    },
    {
        "content": "12 \n \nTuple  Assignment  \nPython  has tuple  assignment  feature  which  enables  you to assign  more  than one variable  at a \ntime.  In here,  we have  assigned  tuple  1 with the college  information  like college  name,  year, \netc. and another  tuple  2 with the values  in it like number  (1, 2, 3… 7). \nFor Example,  \nHere  is the code,  \n >>> tup1 = ('mrcet',  'eng college','2004','cse',  'it','csit');  \n >>> tup2 = (1,2,3,4,5,6,7);  \n >>> print(tup1[0])  \n mrcet  \n >>> print(tup2[1:4",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 99
    },
    {
        "content": "it','csit');  \n >>> tup2 = (1,2,3,4,5,6,7);  \n >>> print(tup1[0])  \n mrcet  \n >>> print(tup2[1:4])  \n (2, 3, 4) \nTuple  1 includes  list of information  of mrcet  \nTuple  2 includes  list of numbers  in it ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 99
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n95 \n We call the value  for [0] in tuple  and for tuple  2 we call the value  between  1 and 4 \nRun the above  code- It gives  name  mrcet  for first tuple  while  for secon d tuple  it gives \nnumber  (2, 3, 4) \nTuple as return values:  \nA Tuple is a comma separated sequence of items. It is created with or without (). Tuples are \nimmutable.   \n# A Python program to return multiple  values from a me",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 100
    },
    {
        "content": "ith or without (). Tuples are \nimmutable.   \n# A Python program to return multiple  values from a method using tuple  \n   \n# This function returns a tuple  \ndef fun():  \n    str = \" mrcet college \" \n    x   = 20  \n    return str, x;  # Return tuple, we could also  \n                          # write (str, x)  \n # Driver code to test above method  \nstr, x = fun() # Assign returned tuple  \nprint(str)  \nprint(x)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/tupretval.py  \nm",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 100
    },
    {
        "content": "  \nprint(x)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/tupretval.py  \nmrcet college  \n20 \n \n Functions can return tuples as return values.  \ndef circleInfo(r):  \n    \"\"\" Return (circumference, area) of a circle of radius r \"\"\"  \n    c = 2 * 3.14159 * r  \n    a = 3.1415 9 * r * r  \n    return (c, a)  \nprint(circleInfo(10))  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/functupretval.py  \n(62.8318, 314.159)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 100
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n96 \n ------------------------------  \ndef f(x):  \n  y0 = x + 1  \n  y1 = x * 3  \n  y2 = y0 ** y3  \n  return (y0, y1, y2)  \n \nTuple comprehension:  \nTuple Comprehensions are special: The result of a tuple comprehension is special. You \nmight expect it to produce a tuple, but what it does is produce a special \"generator\" \nobject that we can iterate over.  \n \nFor example:  \n>>> x = (i for i in 'abc')  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 101
    },
    {
        "content": "pecial \"generator\" \nobject that we can iterate over.  \n \nFor example:  \n>>> x = (i for i in 'abc')   #tuple comprehension  \n>>> x  \n<generator object <genexpr> at 0x033EEC30>  \n \n>>> print(x)  \n<generator object <genexpr> at 0x033EEC30>  \n \nYou might expect this to print as ('a', 'b', 'c') but it prints as <generator object <genexpr> \nat 0x02AAD710> The r esult of a tuple comprehension is not a tuple: it is actually a \ngenerator. The only thing that you need to know now about a generator now is ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 101
    },
    {
        "content": "ple: it is actually a \ngenerator. The only thing that you need to know now about a generator now is that you \ncan iterate over it, but ONLY ONCE.  \n So, given the code  \n \n>>> x = (i for i in 'abc')  \n>>> for i in x:  \n print (i) \n \na \nb \nc \nCreate a list of 2 -tuples like (number, square):  \n>>> z=[(x, x**2) for x in range(6)]  \n>>> z  \n[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 101
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n97 \n  \nSet: \nSimilarly to  list comprehensions , set comprehensions are also supported:  \n \n>>> a = {x for x in 'abracadabra' if x not in 'abc'}  \n>>> a  \n{'r', 'd'}  \n \n>>> x={3*x for x in range(10) if x>5 } \n>>> x  \n{24, 18, 27, 21}  \n \nDictionaries:  \n \nA dictionary is a collection which is unordered, changeable and indexed. In Python \ndictionaries are written with curly brackets, and they have ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 102
    },
    {
        "content": "red, changeable and indexed. In Python \ndictionaries are written with curly brackets, and they have keys and values.  \n Key-value pairs  \n Unordered  \nWe can construct or create dictionary like:  \nX={1:’A’,2:’B’,3:’c’}  \nX=dict([(‘a’,3) (‘b’,4)]  \nX=dict(‘A’=1,’B’ =2)  \n \nExample : \n>>> dict1 = {\"brand\":\"mrcet\",\"model\":\"college\",\"year\":2004}  \n>>> dict1  \n{'brand': 'mrcet', 'model': 'college', 'year': 2004}  \n \nOperations and methods:  \nMethods that are available with dictionary are tabulated ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 102
    },
    {
        "content": "year': 2004}  \n \nOperations and methods:  \nMethods that are available with dictionary are tabulated below. Some of them have already \nbeen used in the above examples.  \nMethod  Description  \nclear()  Remove all items form the dictionary.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 102
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n98 \n copy()  Return a shallow copy of the dictionary.  \nfromkeys(seq[,  v])  Return a new dictionary with keys from  seq and \nvalue equal to  v (defaults to  None).  \nget(key[,d])  Return the value of  key. If  key doesnot exit, \nreturn  d (defaults to  None).  \nitems()  Return a new view of the dictionary's items \n(key, value).  \nkeys()  Return a new view of the dictionary's keys.  \npop(key[,d])  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 103
    },
    {
        "content": "ionary's items \n(key, value).  \nkeys()  Return a new view of the dictionary's keys.  \npop(key[,d])  Remove the item with  key and return its value \nor d if key is not found. If  d is not provided \nand key is not found, raises  KeyError.  \npopitem()  Remove and return an arbitary item (key, \nvalue). Raises  KeyError  if the dictionary is \nempty.  \nsetdefault(key[,d])  If key is in the dictionary, return its value. If \nnot, insert  key with a value of  d and \nreturn  d (defaults to  None).  \nupdat",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 103
    },
    {
        "content": "eturn its value. If \nnot, insert  key with a value of  d and \nreturn  d (defaults to  None).  \nupdate([other])  Update the dictionary with the key/value pairs \nfrom  other, overwriting existing keys.  \nvalues()  Return a new view of the dictionary's values  \n \nBelow are some dictionary operations:  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 103
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n99 \n To access specific value of  a dictionary, we must pass its key,  \n>>> dict1 = {\"brand\":\"mrcet\",\"model\":\"college\",\"year\":2004}  \n>>> x=dict1[\"brand\"]  \n>>> x  \n'mrcet'  \n---------------------  \nTo access keys and values and items of dictionary:  \n>>> dict1 = {\"brand\":\"mrcet\",\"model\":\"college\",\"year\":2004}  \n>>> dict1.keys()  \ndict_keys(['brand', 'model', 'year'])  \n>>> dict1.values()  \ndict_va",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 104
    },
    {
        "content": "ear\":2004}  \n>>> dict1.keys()  \ndict_keys(['brand', 'model', 'year'])  \n>>> dict1.values()  \ndict_values(['mrcet', 'college', 2004])  \n>>> dict1.items()  \ndict_items([('brand', 'mrcet'), ('model', 'college'), ('year', 2004)])  \n-----------------------------------------------  \n>>> for items in dict1.values():  \n print(items)  \n \n  \nmrcet  \ncollege  \n2004  \n \n>>> for items in dict1.keys():  \n print(items)  \n \n  \nbrand  \nmodel  \nyear \n \n>>> for i in dict1.items():  \n print(i)  \n \n  \n('brand', 'mrc",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 104
    },
    {
        "content": "(items)  \n \n  \nbrand  \nmodel  \nyear \n \n>>> for i in dict1.items():  \n print(i)  \n \n  \n('brand', 'mrcet')  \n('model', 'college')  \n('year', 2004)  \n \nSome more  operations like: \n Add/change  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 104
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n100 \n  Remove  \n Length  \n Delete  \n \nAdd/change values:  You can change the value of a specific it em by referring to its key \nname  \n \n>>> dict1 = {\"brand\":\"mrcet\",\"model\":\"college\",\"year\":2004}  \n>>> dict1[\"year\"]=2005  \n>>> dict1  \n{'brand': 'mrcet', 'model': 'college' , 'year': 2005}  \n \nRemove():  It removes or pop the specific item of dictionary.  \n \n>>> dict1 = {\"brand\":\"mrcet\",\"model\":\"",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 105
    },
    {
        "content": "ve():  It removes or pop the specific item of dictionary.  \n \n>>> dict1 = {\"brand\":\"mrcet\",\"model\":\"college\",\"year\":2004}  \n>>> print(dict1.pop(\"model\"))  \ncollege  \n>>> dict1  \n{'brand': 'mrcet', 'year': 2005}  \n \nDelete:  Deletes a particular item.  \n \n>>> x = {1:1, 2:4, 3:9, 4:16, 5:25}  \n>>> del x[5]  \n>>> x  \n \nLength:  we use len() method to get the length of dictionary.  \n \n>>>{1: 1, 2: 4, 3: 9, 4: 16}  \n{1: 1, 2: 4, 3: 9, 4: 16}  \n>>> y=len(x)  \n>>> y  \n4 \nIterating over (key, value) pai",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 105
    },
    {
        "content": "3: 9, 4: 16}  \n{1: 1, 2: 4, 3: 9, 4: 16}  \n>>> y=len(x)  \n>>> y  \n4 \nIterating over (key, value) pairs:  \n>>> x = {1:1, 2:4, 3:9, 4: 16, 5:25}  \n>>> for key in x:  \n print(key, x[key])  \n \n  \n1 1 \n2 4 \n3 9 ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 105
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n101 \n 4 16 \n5 25 \n>>> for k,v in x.items():  \n print(k,v)  \n \n  \n1 1 \n2 4 \n3 9 \n4 16 \n5 25 \n \nList of Dictionaries:  \n \n>>> customers = [{\"uid\":1,\"name\":\"John\"},  \n    {\"uid\":2,\"name\":\"Smith\"},  \n           {\"uid\":3,\"name\":\"Andersson\"},  \n            ] \n>>> >>> print(customers)  \n[{'uid': 1, 'name': 'John'}, {'uid': 2, 'name': 'Smith'}, {'uid': 3, 'name': 'Andersson'}]  \n \n## Print the uid and name",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 106
    },
    {
        "content": "'John'}, {'uid': 2, 'name': 'Smith'}, {'uid': 3, 'name': 'Andersson'}]  \n \n## Print the uid and name of each customer  \n>>> for x in customers:  \n print(x[\"uid\"], x[\"name\"])  \n \n  \n1 John  \n2 Smith  \n3 Andersson  \n \n## Modify an entry , This will change the name of customer 2 from Smith to Charlie  \n>>> customers[2][\"name\"]=\"charlie\"  \n>>> print(customers)  \n[{'uid': 1, 'name': 'John'}, {'uid': 2, 'name': 'Smith'}, {'uid': 3, 'name':  'charlie'}]  \n \n## Add a new field to each entry  \n \n>>> for ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 106
    },
    {
        "content": " 'name': 'Smith'}, {'uid': 3, 'name':  'charlie'}]  \n \n## Add a new field to each entry  \n \n>>> for x in customers:  \n x[\"password\"]=\"123456\" # any initial value  \n \n  \n>>> print(customers)  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 106
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n102 \n [{'uid': 1, 'name': 'John', 'password': '123456'}, {'uid': 2, 'name': 'Smith', 'password': \n'123456'}, {'uid': 3, 'name': 'charlie', 'password': '123456'}]  \n \n## Delete a field  \n>>> del customers[1]  \n>>> print(customers)  \n[{'uid': 1, 'name': 'John', 'password': '123456'}, {'uid': 3, 'name': 'charlie', 'password': \n'123456'}]  \n \n>>> del customers[1]  \n>>> print(customers)  \n[{'uid': 1, 'n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 107
    },
    {
        "content": " 'charlie', 'password': \n'123456'}]  \n \n>>> del customers[1]  \n>>> print(customers)  \n[{'uid': 1, 'name': 'John', 'password': '123456'}]  \n \n## Delete all fields  \n \n>>> for x in customers:  \n del x[\"uid\"]  \n \n  \n>>> x  \n{'name': 'John', 'password': '123456'}  \n \nComprehension:  \n \nDictionary comprehensions can be used to create dictionaries from arbitrary key  and \nvalue expressions:  \n \n>>> z={x: x**2 for x in (2,4,6)}  \n>>> z  \n{2: 4, 4: 16, 6: 36}  \n \n>>> dict11 = {x: x*x for x in range(6)} ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 107
    },
    {
        "content": ": x**2 for x in (2,4,6)}  \n>>> z  \n{2: 4, 4: 16, 6: 36}  \n \n>>> dict11 = {x: x*x for x in range(6)}  \n>>> dict11  \n{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}  \n  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 107
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n103 \n UNIT – V \nFILES, EXCEPTIONS, MODULES, PACKAGES  \nFiles and exception:  text files, reading and writing files, command line arguments, errors \nand exceptions, handling exceptions, modules (datetime, time, OS , calendar, math module), \nExplore packages.  \nFiles, Exceptions, Modules, Packages : \nFiles and exception : \nA file is some information or data which stays in t he computer storage device",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 108
    },
    {
        "content": "iles and exception : \nA file is some information or data which stays in t he computer storage devices. Python  gives \nyou easy ways to manipulate these  files. Generally  files divide  in two categories, \ntext file and binary  file. Text  files are simple text where as the binary  files contain binary \ndata which is only readable by computer.  \n Text files:  In this type of file, Each line of text is terminated with a special character \ncalled EOL (End of Line), which is the new line character ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 108
    },
    {
        "content": "t is terminated with a special character \ncalled EOL (End of Line), which is the new line character (‘ \\n’) in python by default.  \n Binary files:  In this type of file, there is no terminator for a line and the data is stored \nafter converting it into machine understandable binary language.  \nAn exception  is an event, which occurs during the execution of a program that disrupts the \nnormal flow of the program's instructions. In general, when a  Python  script encounters a \nsituation that it c",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 108
    },
    {
        "content": " of the program's instructions. In general, when a  Python  script encounters a \nsituation that it cannot cope with, it raises an  exception . An  exception  is a Python  object \nthat represents an error.  \n \nText files:  \n \nWe can create the text files by using the syntax:  \n \n Variable name =open (“file.txt”, file mode)  \n \nFor ex: f= open (\" hello .txt\",\"w+\")  \n \n We declared the variable f to open a file named hello .txt. Open  takes 2 arguments, the \nfile that we want to open and a string ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 108
    },
    {
        "content": " open a file named hello .txt. Open  takes 2 arguments, the \nfile that we want to open and a string that represents the kinds of permission or \noperation we want to do on  the file  \n Here we used \"w\" letter in our argument, which indicates write and the plus sign that \nmeans it will create a file if it does not exist in library  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 108
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n104 \n  The available option beside \"w\" are \"r\" for read and \"a\" for append and plus sign \nmeans if it is not  there then create it  \n \nFile Modes in Python : \nMode  Description  \n'r' This is the default mode. It Opens file for reading.  \n'w' This Mode Opens file for writing.  \nIf file does not exist, it creates a new file.  \nIf file exists it truncates the file.  \n'x' Creates  a new file. If file ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 109
    },
    {
        "content": ", it creates a new file.  \nIf file exists it truncates the file.  \n'x' Creates  a new file. If file already exists, the operation fails.  \n'a' Open file in append mode.  \nIf file does not exist, it creates a new file.  \n't' This is the default mode. It opens in text mode.  \n'b' This opens in binary mode.  \n'+' This will open a file for reading and writing (updating)  \n \n \nReading and Writing files:  \n \nThe following image shows how to create and open a text file in notepad from command \nprompt  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 109
    },
    {
        "content": ":  \n \nThe following image shows how to create and open a text file in notepad from command \nprompt  \n \n \n \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 109
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n105 \n  \n \n \n(or) \n \n \n \nHit on enter then it shows the following whether to open or not?  \n \n \n \nClick on “yes” to open else “no” to cancel  \n \n# Write a python program to open and read a file  \n \na=open(“one.txt”,”r”)  \nprint(a.read())  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 110
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n106 \n a.close()  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/filess/f1.py  \nwelcome to python programming  \n \n(or) \n \n \n \nNote: All the program files and text files need to saved together in a particular file then \nonly the program performs the operations in the given file mode  \n \n \n \n \nf.close()  ---- This will close the instance of the file   somefile .txt stored  \n \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 111
    },
    {
        "content": "mode  \n \n \n \n \nf.close()  ---- This will close the instance of the file   somefile .txt stored  \n \n \n# Write a python program to open and write “hello world” into a file?  \n \nf=open(\"1 .txt\",\"a\")  \nf.write(\"hello world\")  \nf.close()  \nOutput:  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 111
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n107 \n  \n(or) \n \nNote: In the above program the 1.txt file is created automatically and adds hello world \ninto txt file  \n \nIf we keep on executing the same program for more than one time then it append the data \nthat many times  \n \n# Write a python program to write the content “hi python programming” for the \nexisting  file . \n \nf=open(\"1.txt\",'w')  \nf.write(\"hi python programming\")  \nf.close()  \nO",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 112
    },
    {
        "content": " for the \nexisting  file . \n \nf=open(\"1.txt\",'w')  \nf.write(\"hi python programming\")  \nf.close()  \nOutput:  \n \n \nIn the above program the hello txt file consist of data like  \n \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 112
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n108 \n But when we try to write some data on to the same file it overwrites and saves with the \ncurrent data (check output)  \n \n# Write a python program to open and write the content to file and read it . \n \nfo=open(\"ab c.txt\",\"w+\")  \nfo.write(\"Python Programming\")  \nprint(fo.read())  \nfo.close()  \nOutput:  \n \n(or) \n \n \nNote: It creates the abc.txt file automatically and writes the data into it  \n \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 113
    },
    {
        "content": "tput:  \n \n(or) \n \n \nNote: It creates the abc.txt file automatically and writes the data into it  \n \n  \n \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 113
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n109 \n  \nCommand line arguments:  \n \nThe command line arguments must be given whenever we want to give the input before the \nstart of the script, while on the other hand, raw_input() is used to get the input while the \npython program / script is running.  \n \nThe command line arguments in python can be process ed by using either ‘sys’ module,  \n‘argparse’ m odule and ‘getopt’ module.  \n \n‘sys’ module",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 114
    },
    {
        "content": " process ed by using either ‘sys’ module,  \n‘argparse’ m odule and ‘getopt’ module.  \n \n‘sys’ module :  \n \nPython sys module  stores the command line arguments into a list, we can access it \nusing  sys.argv. This is very useful and simple way to read command line arguments as \nString.  \nsys.argv  is the list of commandline arguments passed to the Python program. argv represents \nall the items that come along via the command line input, it's basically an array holding the \ncommand line arguments ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 114
    },
    {
        "content": " come along via the command line input, it's basically an array holding the \ncommand line arguments of our program  \n \n>>> sys.modules.keys()   -- this prints so many dict elements in the form of list.  \n \n# Python code to demonstrate the use of 'sys'  module for command line arguments  \n   \nimport sys  \n   \n# command line arguments are stored in the form  \n# of list in sys.argv  \nargumentList = sys.argv  \nprint(argumentList)  \n   \n# Print the name of file  \nprint(sys.argv[0])  \n   \n# Print the ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 114
    },
    {
        "content": "ys.argv  \nprint(argumentList)  \n   \n# Print the name of file  \nprint(sys.argv[0])  \n   \n# Print the first argument after the name of file  \n#print(sys.argv[1])  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/cmndlinarg.py  \n \n['C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/cmndlinarg.py']  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/cmndlinarg.py  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 114
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n110 \n Note:  Since my list consist of only one element at ‘0’ index so it prints only that list \nelement, if we try to access at index position ‘1’ then it shows the error like,  \n \nIndexError: list index out of range  \n------------------  \n \nimport sys  \n \nprint(type(sys.argv))  \nprint('The command line arguments are:')  \nfor i in sys.argv:  \n    print(i)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 115
    },
    {
        "content": "line arguments are:')  \nfor i in sys.argv:  \n    print(i)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/symod.py ==  \n<class 'list'>  \nThe command line arguments are:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/symod.py  \n \n# write a python program to get python version.  \nimport sys  \nprint(\"System version is:\")  \nprint(sys.version)  \nprint(\"Version Information is:\")  \nprint(sys.version_info)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Py",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 115
    },
    {
        "content": "mation is:\")  \nprint(sys.version_info)  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/s1.py =  \nSystem version is:  \n3.8.0 (tags/v3.8.0:fa919fd, Oct 14 2019, 19:21:23) [MSC v.1916 32 bit (Intel)]  \nVersion Information is:  \nsys.version_info(major=3, minor=8, micro=0, releaselevel ='final', serial=0)  \n \n‘argparse’ module : \n \nPython getopt module is very similar in working as the C  getopt () function for parsing \ncommand -line parameters.  Python getopt module is u",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 115
    },
    {
        "content": "rking as the C  getopt () function for parsing \ncommand -line parameters.  Python getopt module is useful in parsing command line \narguments where we want user to enter some opti ons too.   \n \n>>> parser = argparse.ArgumentParser(description='Process some integers.')  \n \n#---------  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 115
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n111 \n import argparse  \n \nparser = argparse.ArgumentParser()  \nprint(parser.parse_args())  \n \n \n‘getopt’ module : \n \nPython argparse module is the preferred way to parse command line arguments. It provides a \nlot of option such as positional arguments, default value for arguments, help message, \nspecifying data type of argument etc  \n \nIt parses the command line options and parameter list. The sign",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 116
    },
    {
        "content": "ifying data type of argument etc  \n \nIt parses the command line options and parameter list. The signature of this function is \nment ioned below:  \n \ngetopt.getopt(args, shortopts, longopts=[  ]) \n \n args are the arguments to be passed.  \n shortopts  is the options this script accepts.  \n Optional parameter,  longopts  is the list of String parameters this function accepts \nwhich should be supported. Note that the  -- should not be prepended with option \nnames.  \n \n \n \n-h    ---------  print h",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 116
    },
    {
        "content": "rted. Note that the  -- should not be prepended with option \nnames.  \n \n \n \n-h    ---------  print help and usage message  \n-m   ---------  accept custom option value  \n-d    ---------  run the script in debug mode  \n \nimport getopt  \nimport sys  \n \nargv = sys.argv[0:]  \ntry: \n    opts, args = getopt.getopt(argv, 'hm:d', ['help', 'my_file='])  \n    #print(opts)  \n    print(args)  \nexcept getopt.GetoptError:  \n    # Print a message or do something useful  \n    print('Something went wrong!')  \n   ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 116
    },
    {
        "content": "toptError:  \n    # Print a message or do something useful  \n    print('Something went wrong!')  \n    sys.exit(2)  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 116
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n112 \n Output:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/gtopt.py ==  \n \n['C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/gtopt.py']  \n \nErrors and Exceptions:  \nPython Errors  and Built -in Exceptions:  Python  (interpreter) raises exceptions when it \nencounters  errors . When writing a program, we, more often than not, will \nencounter  errors . Error  caused by not fol",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 117
    },
    {
        "content": " When writing a program, we, more often than not, will \nencounter  errors . Error  caused by not following the proper structure (syntax) of the language \nis called syntax  error  or parsing  error  \nZeroDivisionError : \nZeroDivisionError in Python indicates that the second argument used in a division (or \nmodulo) operation was zero . \n \nOverflowError : \nOverflowError  in Python indicates that an arithmetic operation has exceeded the limits of \nthe current Python runtime. This is typically due to",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 117
    },
    {
        "content": "rithmetic operation has exceeded the limits of \nthe current Python runtime. This is typically due to excessivel y large float  values, as integer \nvalues that are too big will opt to raise memory errors instead.  \nImportError : \nIt is raised when you try to import a module which does not exist. This may happen if you \nmade a typing mistake in the module name or the module doesn't exist in its standard path. \nIn the example below, a module named \"non_existing_module\" is being imported but it \ndoe",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 117
    },
    {
        "content": "dard path. \nIn the example below, a module named \"non_existing_module\" is being imported but it \ndoesn't exist, hence an import error  exception is raised.  \nIndexError : \nAn IndexError exception is raised when you refer a sequence which is out of range. In the \nexample below, the list abc contains only 3 entries, but the 4th index is being accessed, \nwhich will result an IndexError exception.  \nTypeError : \nWhen two unrelated type of objects are combined,  TypeErrorexception is raised.In exampl",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 117
    },
    {
        "content": "ypeError : \nWhen two unrelated type of objects are combined,  TypeErrorexception is raised.In example  \nbelow, an int and a string  is added, which will result in TypeError exception.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 117
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n113 \n  IndentationError:  \nUnexpected  indent. As mentioned in the \"expected an  indentedblock\" section,  Python  not \nonly insists on  indentation, it insists on consistentindentation. You are free to choose the \nnumber of spaces of  indentation  to use, but you then need to stick with it.  \nSyntax errors : \nThese are the most basic type of  error. They arise when the  Python  parser   is unable t",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 118
    },
    {
        "content": "errors : \nThese are the most basic type of  error. They arise when the  Python  parser   is unable to \nunderstand a line of code.  Syntax errors  are almost a lways fatal, i.e. there is almost never a \nway to successfully execute a piece of code containing syntax errors.  \nRun-time error : \n A run-time error  happens when  Python  understands what you  are saying, but runs into \ntrouble when following your instructions.  \nKey Error  : \nPython raises a  KeyError  whenever a dict() object is reque",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 118
    },
    {
        "content": "wing your instructions.  \nKey Error  : \nPython raises a  KeyError  whenever a dict() object is requested (using the \nformat  a = adict[key]) and the key is not in the dictionary.  \n Value Error : \nIn Python, a value is the information that is stored within a certain object. To encounter a \nValueError in Python means that is a problem with the content of the object you tried to \nassign the value to.  \nPython  has many built -in exceptions  which forces your program to output an error when  \nsomet",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 118
    },
    {
        "content": ".  \nPython  has many built -in exceptions  which forces your program to output an error when  \nsomething in it goes wrong. In Python, users can define  such exceptions  by creating a new \nclass. This exception  class has to be derived, either directly or indirectly, \nfrom  Exception  class.  \nDifferent types of exceptions:  \n ArrayIndexOutOfBoundException.  \n ClassNotFoundException.  \n FileNotFoundException.  \n IOException.  \n InterruptedException.  \n NoSuchFieldException.  \n NoSuchMethod",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 118
    },
    {
        "content": "oundException.  \n IOException.  \n InterruptedException.  \n NoSuchFieldException.  \n NoSuchMethodException  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 118
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n114 \n Handling Exceptions:  \nThe cause of an exception is often external to the program itself. For example, an incorrect \ninput, a malfunctioning IO device etc. Because the program abruptly terminates on \nencountering an exception, it may cause damage to system resources, such as files. Hence, \nthe exceptions should be properly handled so that an abrupt termination of the program is \nprevented.  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 119
    },
    {
        "content": "exceptions should be properly handled so that an abrupt termination of the program is \nprevented.  \nPython uses  try and except  keywords to han dle exceptions. Both keywords are followed by \nindented blocks.  \nSyntax:  \ntry : \n    #statements in try block  \nexcept :  \n    #executed when error in try block  \nTypically we see, most of the times  \n Syntactical errors  (wrong spelling, colon ( : ) missing ….),  \nAt developer level and compile level it gives errors.  \n \n Logical errors  (2+2=4, in",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 119
    },
    {
        "content": "issing ….),  \nAt developer level and compile level it gives errors.  \n \n Logical errors  (2+2=4, instead if we get output as 3 i.e., wrong output …..,),  \nAs a developer we test the application, during that time logical error may obtained.  \n \n Run time error  (In this case, if the user doesn’t know to give input, 5/6 is ok but if \nthe user say 6 and 0 i.e.,6/0 (shows error a number cannot be divided by zero))  \nThis is not easy compared to the above two errors  because it is not done by the \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 119
    },
    {
        "content": "vided by zero))  \nThis is not easy compared to the above two errors  because it is not done by the \nsystem, it is (mistake) done by the user.  \nThe things we need to observe are:  \n1. You should be able to understand the mistakes ; the error might be done by user, DB \nconnection or server.  \n2. Whenever there is an error execution should not stop.  \nEx: Banking Transaction  \n3. The aim i s execution should not stop even though an error occurs.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 119
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n115 \n  \nFor ex:  \na=5 \nb=2 \nprint(a/b)  \nprint(\" Bye\") \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex1.py  \n2.5 \nBye \n The above is normal execution with no error, but if we say when b=0, it is a \ncritical and gives error, see below  \na=5 \nb=0 \nprint(a/b)  \nprint(\"bye\")  #this has to be printed, but abnormal termination  \nOutput:  \nTraceback (most recent call last):  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 120
    },
    {
        "content": "  #this has to be printed, but abnormal termination  \nOutput:  \nTraceback (most recent call last):  \n  File \"C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex2.py\", line \n3, in <module>  \n    print(a/b)  \nZeroDivisionError: division by zero  \n To overcome this we handle exceptions using except keyword  \na=5 \nb=0 ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 120
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n116 \n try: \n    print(a/b)  \nexcept Exception:  \n    print(\"number can not be divided by zero\")  \n    print(\"bye\")  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex3.py  \nnumber can not be divided by zero  \nbye \n The except block executes only when try block has an error, check it below  \na=5 \nb=2 \ntry: \n    print(a/b)  \nexcept Exception:  \n    print(\"number can not be ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 121
    },
    {
        "content": " check it below  \na=5 \nb=2 \ntry: \n    print(a/b)  \nexcept Exception:  \n    print(\"number can not be divided by zero\")  \n    print(\"bye\")  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex4.py  \n2.5 \n For example if you want to print the message like what is an error  in a program  \nthen we use “e” which is the representation or object of an exception.  \na=5 \nb=0 \ntry: ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 121
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n117 \n     print(a/b)  \nexcept Exception as e:  \n    print(\"number can not be divided by zero\",e)  \nprint(\"bye\")  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Pytho n38-32/pyyy/ex5.py  \nnumber can not be divided by zero division by zero  \nbye  \n (Type of error)  \nLet us see some more examples:  \nI don’t want to print bye but I want to close the file whenever it is opened.  \na=5 \nb=2 \ntry:",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 122
    },
    {
        "content": "es:  \nI don’t want to print bye but I want to close the file whenever it is opened.  \na=5 \nb=2 \ntry: \n    print(\"resource opened\")  \n    print(a/b)  \n    print(\"resource closed\")  \nexcept Exception as e:  \n    print(\"number can not be divided by zero\",e)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex6.py  \nresource opened  \n2.5 \nresource closed  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 122
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n118 \n  Note: the file is opened and closed well, but see by changing the value of b to 0,  \na=5 \nb=0 \ntry: \n    print(\"resource opened\")  \n    print(a/b)  \n    print(\"resource closed\")  \nexcept Exception as e:  \n    print(\"number can not be divided by zero\",e)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Pro grams/Python/Python38 -32/pyyy/ex7.py  \nresource opened  \nnumber can not be divided by zero di",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 123
    },
    {
        "content": "l/Pro grams/Python/Python38 -32/pyyy/ex7.py  \nresource opened  \nnumber can not be divided by zero division by zero  \n Note: resource not closed  \n To overcome this, keep  print(“resource closed”) in except block, see it  \na=5 \nb=0 \ntry: \n    print(\"resource opened\")  \n    print(a/b)  \nexcept Exception as e:  \n        print(\"number can not be divided by zero\",e)  \n        print(\"resource closed\")  \nOutput:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 123
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n119 \n C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex8.py  \nresource opened  \nnumber can not be divided by zero divis ion by zero  \nresource closed  \n The result is fine that the file is opened and closed, but again change the value of \nb to back ( i.e., value  2 or other than zero ) \na=5 \nb=2 \ntry: \n    print(\"resource opened\")  \n    print(a/b)  \nexcept Exception as e:  \n       ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 124
    },
    {
        "content": " ) \na=5 \nb=2 \ntry: \n    print(\"resource opened\")  \n    print(a/b)  \nexcept Exception as e:  \n        print(\"num ber can not be divided by zero\",e)  \n        print(\"resource closed\")  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex9.py  \nresource opened  \n2.5 \n But again the same problem file/resource is not closed  \n To overcome this python has a feature called finally:  \n \n                                                         This block gets executed  though we",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 124
    },
    {
        "content": "ly:  \n \n                                                         This block gets executed  though we get an error or not   \nNote:  Except block executes, only when  try block has an error , but finally block \nexecutes, even though you get an exception.  \na=5 \nb=0 \n  \ntry: ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 124
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n120 \n                print(\"resource open\")  \n               print(a/b)  \n               k=int(input(\"enter a number\"))  \n               print(k)  \nexcept ZeroDivisionError as e:  \n               print(\"the  value can not be divided by zero\",e)  \nfinally:  \n               print(\"resource closed\")  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex10.py  \nresource open  \nth",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 125
    },
    {
        "content": "utput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex10.py  \nresource open  \nthe value can not be divided by zero division by zero  \nresource closed  \n \n change  the value of b to 2  for above program , you see the output like  \n \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex10.py  \nresource open  \n2.5 \nenter a number 6  \n6 \nresource closed  \n \n Instead give input as some character or string for above program, check the \noutput  \nC:/Users/MRCET/AppData/",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 125
    },
    {
        "content": "ive input as some character or string for above program, check the \noutput  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex10.py  \nresource open  \n2.5 \nenter a number p  \nresource closed  \nTraceback (most recent call last):  \n  File \"C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex10.py\", lin e \n7, in <module>  \n    k=int(input(\"enter a number\"))  \nValueError: invalid literal for int() with base 10: ' p'  \n ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 125
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n121 \n #--------------------  \na=5 \nb=0 \n \ntry: \n               print(\"resource open\")  \n               print(a/b)  \n               k=int(input(\"enter a number\"))  \n               print(k)  \nexcept ZeroDivisionError as e:  \n               print(\"the value can not be divided by zero\",e)  \nexcept ValueError as e:  \n               print(\"invalid input\")  \nexcept Exception as e:  \n               print(\"",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 126
    },
    {
        "content": "rror as e:  \n               print(\"invalid input\")  \nexcept Exception as e:  \n               print(\"something went wrong...\",e)  \n                \nfinally:  \n               print(\"resource closed\")  \n \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex11.py  \nresource open  \nthe value can not be divided by zero division by zero  \nresource closed  \n \n Change the value of  b to 2 and give the input as some character or string  (other \nthan int)  \nC:/Users/MRCET/AppData/Lo",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 126
    },
    {
        "content": "b to 2 and give the input as some character or string  (other \nthan int)  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ex12.py  \nresource open  \n2.5 \nenter a number p  \ninvalid input  \nresource closed  \n \nModules (Date, Time, os, calendar, math):  \n• Modules refer to a file containing Python statements and definitions.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 126
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n122 \n • We use modules to break down large programs into small manageable and organized \nfiles. Furthermore, modules provide reusability of code.  \n• We can define our most used functions in a module and import it , instead of copying \ntheir definitions into different programs.  \n• Modular programming  refers to the process of breaking a large, unwieldy \nprogramming task into separate, smaller, mor",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 127
    },
    {
        "content": "g  refers to the process of breaking a large, unwieldy \nprogramming task into separate, smaller, more manageable subtasks or  modules .  \nAdvantages :  \n• Simplicity:  Rather than focusing on the entire problem at hand, a module typically \nfocuses on one relatively small portion of the problem. If you’re working on a single \nmodule, you’ll have a smaller problem domain to wrap your head around. This makes \ndevelopment easier and less e rror-prone.  \n• Maintainability:  Modules are typically desi",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 127
    },
    {
        "content": "is makes \ndevelopment easier and less e rror-prone.  \n• Maintainability:  Modules are typically designed so that they enforce logical \nboundaries between different problem domains. If modules are written in a way that \nminimizes interdependency, there is decreased likelihood that modifications to a \nsingle module will have an impact on other parts of the program. This makes it more \nviable for a team of many programmers to work collaboratively on a large application.  \n• Reusability:  Functional",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 127
    },
    {
        "content": "eam of many programmers to work collaboratively on a large application.  \n• Reusability:  Functionality defined in a single module can be easily reused (through \nan ap propriately defined interface) by other parts of the application. This eliminates \nthe need to recreate duplicate code.  \n• Scoping:  Modules typically define a separate  namespace , which helps avoid \ncollisions between identifiers in different areas of a program.   \n• Functions , modules  and packages  are all constructs in Pyth",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 127
    },
    {
        "content": " in different areas of a program.   \n• Functions , modules  and packages  are all constructs in Python that promote code \nmodularization.  \nA file containing Python code, for e.g.:  example.py, is called a module and its module name \nwould be  example.  \n>>> def add(a,b):  \n result=a+b   \n return result  \n          \"\"\"This program adds two numbers and return the result\"\"“  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 127
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n123 \n  \nHere, we have defined a  function  add()  inside a module named  example. The function takes \nin two numbers and returns their sum.  \nHow to import the module is:  \n• We can import the definitions inside a module to another module or the Interactive \ninterpreter in Python.  \n• We use the  import  keyword to do this. To import our previously defined \nmodule  example  we type the following in",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 128
    },
    {
        "content": "ort  keyword to do this. To import our previously defined \nmodule  example  we type the following in  the Python prompt.  \n• Using the module name we can access the function using dot (.) operation. For   Eg: \n>>> import example  \n>>> example.add(5,5)  \n10 \n• Python has a ton of standard modules available.  Standard modules can be imported \nthe same way as we import our  user-defined modules.  \nReloading a module:  \ndef hi(a,b):  \n    print(a+b)  \nhi(4,4)  \nOutput:  \nC:/Users/MRCET/AppData/Local",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 128
    },
    {
        "content": "loading a module:  \ndef hi(a,b):  \n    print(a+b)  \nhi(4,4)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/add.py  \n8 \n>>> import add  \n8 \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 128
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n124 \n >>> import add  \n>>> import add  \n>>> \nPython provides a neat way of doing this. We can use the  reload()  function inside \nthe imp module to reload a module. This is how its done.  \n• >>> import imp  \n• >>> import my_module  \n• This code got executed >>> import my_module >>> imp.reload(my_module) This \ncode got executed <module 'my_module' from '. \\\\my_module.py'> how its done.  \n \n>>> impor",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 129
    },
    {
        "content": "le) This \ncode got executed <module 'my_module' from '. \\\\my_module.py'> how its done.  \n \n>>> import imp  \n>>> import add  \n>>> imp.reload(add)  \n8 \n<module 'add' from 'C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -\n32/pyyy \\\\add.py'>  \nThe dir() built -in function  \n>>> import  example  \n>>> dir(example)  \n['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', \n'__spec__', 'add']  \n>>> dir()  \n['__annotations__', '__builtins__', '__doc__', '__fi",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 129
    },
    {
        "content": "__package__', \n'__spec__', 'add']  \n>>> dir()  \n['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', \n'__package__', '__spe c__', '__warningregistry__', 'add', 'example', 'hi', 'imp']  \nIt shows all built -in and user -defined modules.  \nFor ex:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 129
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n125 \n >>> example.__name__  \n'example'  \nDate time  module:  \n# Write a python program to display date, time  \n>>> import datetime  \n>>> a=datetime.datetime(2019,5,27,6,35,40)  \n>>> a  \ndatetime.datetime(2019, 5, 27, 6, 35, 40)  \n# write  a python program to display date  \nimport datetime  \na=datetime.date(2000,9,18)  \nprint(a)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/p",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 130
    },
    {
        "content": "e.date(2000,9,18)  \nprint(a)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/d1.py = \n2000 -09-18 \n# write a python program to display time  \nimport datetime  \na=datetime.time(5,3)  \nprint(a)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/d1.py =  \n05:03:00  \n#write a python program to print date, time for today and now.  \nimport  datetime  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 130
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n126 \n a=datetime.datetime.today()  \nb=datetime.datetime.now()  \nprint(a)  \nprint(b)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/d1.py =  \n2019 -11-29 12:49:52.235581  \n2019 -11-29 12:49:52.235581  \n#write a python program to add some days to your present date and print the date \nadded.  \nimport datetime  \na=datetime.date.today()  \nb=datetime.timedelta(days=7)  \nprint(",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 131
    },
    {
        "content": "the date \nadded.  \nimport datetime  \na=datetime.date.today()  \nb=datetime.timedelta(days=7)  \nprint(a+b)  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/d1.py =  \n2019 -12-06 \n#write a  python program to print the no . of days to write to reach your birthday  \nimport datetime  \na=datetime.date.today()  \nb=datetime.date(2020,5,27)  \nc=b-a \nprint(c)  \nOutput:  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 131
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n127 \n C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/d1.py =  \n180 days, 0:00:00  \n#write an python program to print da te, time using date and time functions  \nimport datetime  \nt=datetime.datetime.today()  \nprint(t.date())  \nprint(t.time())  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/d1.py =  \n2019 -11-29 \n12:53:39.226763  \nTime module:  \n#write a py",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 132
    },
    {
        "content": "rograms/Python/Python38 -32/pyyy/d1.py =  \n2019 -11-29 \n12:53:39.226763  \nTime module:  \n#write a python program  to display time.  \nimport time  \nprint(time.time())  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/t1.py =  \n1575012547.1584706  \n#write a  python program to get structure of time stamp . \nimport time  \nprint(time.localtime(time.time()))  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/t1.py =  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 132
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n128 \n time.struct_time(tm_year=2019, tm_mon=11, tm_mday=29, tm_hour=13, tm_min=1, \ntm_sec=15, tm_wday=4, tm_yday=333, tm_isdst=0)  \n#write a python program to make a time stamp.  \nimport ti me \na=(1999,5,27,7,20,15,1,27,0)  \nprint(time.mktime(a))  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/t1.py =  \n927769815.0  \n#write a python program using sleep().  \nimport time  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 133
    },
    {
        "content": "on/Python38 -32/pyyy/t1.py =  \n927769815.0  \n#write a python program using sleep().  \nimport time  \ntime.sleep(6)      #prints after 6 seconds  \nprint(\"Python  Lab\")     \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/t1.py =  \nPython  Lab   (#prints after 6 seconds)  \nos module:  \n>>> import os  \n>>> os.name  \n'nt' \n>>> os.getcwd()  \n'C:\\\\Users \\\\MRCET \\\\AppData \\\\Local \\\\Programs \\\\Python \\\\Python38 -32\\\\pyyy'  \n>>> os.mkdir(\"temp1\")  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 133
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n129 \n  \nNote:  temp1 dir is created  \n>>> os.getcwd()  \n'C:\\\\Users \\\\MRCET \\\\AppData \\\\Local \\\\Programs \\\\Python \\\\Python38 -32\\\\pyyy'  \n>>> open(\"t1.py\",\"a\")  \n<_io.TextIOWrapper name='t1.py' mode='a' encoding='cp1252'>  \n>>> os.access(\"t1.py\",os.F_OK)  \nTrue  \n>>> os.access(\"t1.py\",os.W_OK)  \nTrue  \n>>> os.rename(\"t1.py\",\"t3.py\")  \n>>> os.access(\"t1.py\",os.F_OK)  \nFalse  \n>>> os.access(\"t3.py\",os",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 134
    },
    {
        "content": " \n>>> os.rename(\"t1.py\",\"t3.py\")  \n>>> os.access(\"t1.py\",os.F_OK)  \nFalse  \n>>> os.access(\"t3.py\",os.F_OK)  \nTrue  \n>>> os.rmdir('temp1')  \n(or) \nos.rmdir('C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/ temp1')  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 134
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n130 \n  \nNote:  Temp1dir is removed  \n>>> os.remove(\"t3.py\")  \nNote:  We can check with the following cmd whether removed or not  \n>>> os.access(\"t3.py\",os.F_OK)  \nFalse  \n>>> os.listdir()  \n['add.py', 'ali.py', 'alia.py', 'arr.py', 'arr2.py', 'arr3.py', 'arr4.py', 'arr5.py', 'arr6.py', 'br.py', \n'br2.py', 'bubb.py', 'bubb2.py', 'bubb3.py', 'bubb4.py', 'bubbdesc.py', 'clo.py', 'cmndlinarg.py', \n'com",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 135
    },
    {
        "content": ".py', 'bubb.py', 'bubb2.py', 'bubb3.py', 'bubb4.py', 'bubbdesc.py', 'clo.py', 'cmndlinarg.py', \n'comm.py', 'con1.py', 'cont.py', 'cont2.py', 'd1.py', 'dic.py', 'e1.py', 'example.py', 'f1.y.py', \n'flowof.py', 'fr.py', 'fr2.py', 'fr3.py ', 'fu.py', 'fu1.py', 'if1.py', 'if2.py', 'ifelif.py', 'ifelse.py', \n'iff.py', 'insertdesc.py', 'inserti.py', 'k1.py', 'l1.py', 'l2.py', 'link1.py', 'linklisttt.py', 'lis.py', \n'listlooop.py', 'm1.py', 'merg.py', 'nesforr.py', 'nestedif.py', 'opprec.py', 'pa raarg.",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 135
    },
    {
        "content": " 'lis.py', \n'listlooop.py', 'm1.py', 'merg.py', 'nesforr.py', 'nestedif.py', 'opprec.py', 'pa raarg.py', \n'qucksort.py', 'qukdesc.py', 'quu.py', 'r.py', 'rec.py', 'ret.py', 'rn.py', 's1.py', 'scoglo.py', \n'selecasce.py', 'selectdecs.py', 'stk.py', 'strmodl.py', 'strr.py', 'strr1.py', 'strr2.py', 'strr3.py', \n'strr4.py', 'strrmodl.py', 'wh.py', 'wh1.py ', 'wh2.py', 'wh3.py', 'wh4.py', 'wh5.py', \n'__pycache__']  \n>>> os.listdir('C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32') \n['argpar",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 135
    },
    {
        "content": "_pycache__']  \n>>> os.listdir('C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32') \n['argpar.py', 'br.py', 'bu.py', 'cmndlinarg.py', 'DLLs', 'Doc', 'f1.py', 'f1.txt', 'filess', \n'functupretval.py', 'funturet. py', 'gtopt.py', 'include', 'Lib', 'libs', 'LICENSE.txt', 'lisparam.py', \n'mysite', 'NEWS.txt', 'niru', 'python.exe', 'python3.dll', 'python38.dll', 'pythonw.exe', 'pyyy', \n'Scripts', 'srp.py', 'sy.py', 'symod.py', 'tcl', 'the_weather', 'Tools', 'tupretval.p y', \n'vcruntime140.dll']",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 135
    },
    {
        "content": " 'srp.py', 'sy.py', 'symod.py', 'tcl', 'the_weather', 'Tools', 'tupretval.p y', \n'vcruntime140.dll']  \n \nCalendar  module:  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 135
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n131 \n #write a python program to display a particular month of a year using calendar \nmodule.  \nimport calendar  \nprint(calendar.month(2020,1))  \nOutput:  \n \n# write a python program to check whether the given year is leap or not. \nimport calendar  \nprint(calendar.isleap(2021))  \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/cl1.py  \nFalse  \n#write a python program to pri",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 136
    },
    {
        "content": "RCET/AppData/Local/Programs/Python/Python38 -32/pyyy/cl1.py  \nFalse  \n#write a python program to print all the months of given year.  \nimport calendar  \nprint(calendar.calendar(2020,1,1,1))  \nOutput:  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 136
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n132 \n  \nmath module:  \n# write a python program which accepts the radius of a circle from user and computes \nthe area.  \nimport math  \nr=int(input(\"Enter radius:\"))  \narea=math.pi*r*r  \nprint(\"Area of circle is:\",area)  \nOutput:  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 137
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n133 \n C:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/pyyy/m.py =  \nEnter radius:4  \nArea of circle is: 50.26548245743669  \n>>> import math  \n>>> print(\"The value of pi is\", math.pi)  \nO/P: The value of pi is 3.141592653589793  \nImport with renaming:  \n• We can import a module by renaming it as follows.   \n• For Eg:  \n  >>> import math as m  \n >>> print(\"The value of pi is\", m.pi)  \nO/P: ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 138
    },
    {
        "content": "t as follows.   \n• For Eg:  \n  >>> import math as m  \n >>> print(\"The value of pi is\", m.pi)  \nO/P: The value of pi is 3.141592653589793  \n \n• We have renamed the  math  module as  m. This can save us typing time in some cases.   \n• Note  that the name  math  is not recognized in our scope. Hence,  math.pi  is \ninvalid,  m.pi is the correct implementation.  \nPython from...import statement:  \n• We can import specific names from a module without importing the module as a \nwhole. Here is an example",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 138
    },
    {
        "content": "can import specific names from a module without importing the module as a \nwhole. Here is an example.  \n >>> from math import pi  \n >>> print(\"The value of pi is\", pi)  \nO/P: The value of pi is 3.141592653589793  \n• We imported only the attribute pi from the module.  \n• In such case we don't use the dot operator. We could have imported multiple attributes \nas follows.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 138
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n134 \n  >>> from math i mport pi, e  \n >>> pi  \n 3.141592653589793  \n >>> e  \n 2.718281828459045  \nImport all names:  \n• We can import all names(definitions) from a module using the following construct.  \n >>>from math import *  \n >>>print(\"The value of pi is\", pi)  \n• We imported all the definitions from the math module. This makes all names except \nthose beginnig with an underscore, visible in our",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 139
    },
    {
        "content": "from the math module. This makes all names except \nthose beginnig with an underscore, visible in our scope.  \nExplore packages:  \n• We don't usually store all of our files in our computer in the same location. We use a \nwell-organi zed hierarchy of directories for easier access.  \n• Similar files are kept in the same directory, for example, we may keep all the songs in \nthe \"music\" directory. Analogous to this, Python has packages for directories \nand modules  for files.  \n• As our application p",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 139
    },
    {
        "content": "ogous to this, Python has packages for directories \nand modules  for files.  \n• As our application program grows larger in size with a lot of modules, we place \nsimilar modules in one package and different modules in different packages. This \nmakes a project (program) easy to manage and conceptually clear.  \n• Similar, as a directory can contain sub -directories and files, a Python package can \nhave sub -packages and modules.  \n• A directory must contain a file named  __init__.py  in order for P",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 139
    },
    {
        "content": "ve sub -packages and modules.  \n• A directory must contain a file named  __init__.py  in order for Python to consider it as \na package. This file can be left empty but we generally place the initialization code for \nthat package in this file.  \n• Here is an example. Suppose we are developing a game, one possible organization of \npackages and modules could be as shown in the figure below.  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 139
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n135 \n  \n• If a file named  __init__.py  is present in a package directory, it is invoked when the \npackage or a module in the package is imported. This can be used for execution of \npackage initialization code, such as initialization of package -level data.  \n• For example     __init__.py   \n• A module  in the package can access the global by importing it in turn  \n• We can import modules from pack",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 140
    },
    {
        "content": "le  in the package can access the global by importing it in turn  \n• We can import modules from packages using the dot (.) operator.  \n• For example, if want to import the  start module in the above example, it is done as \nfollows.  \n• import Game. Level.start  \n• Now if this module contains a  function  named  select_difficulty(), we must use the \nfull name to reference it.  \n• Game.Level.start.select_difficulty(2)  \n",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 140
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n136 \n • If this construct seems len gthy, we can import the module without the package prefix \nas follows.  \n• from Game.Level import start  \n• We can now call the function simply as follows.  \n• start.select_difficulty(2)  \n• Yet another way of importing just the required function (or class or variable) form a \nmodule within a package would be as follows.  \n• from Game.Level.start import select_di",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 141
    },
    {
        "content": "ble) form a \nmodule within a package would be as follows.  \n• from Game.Level.start import select_difficulty  \n• Now we can directly call this function.  \n• select_difficulty(2)  \nExamples:  \n#Write a python program to create a package (II YEAR),sub -\npackage(CSE),modules(studen t) and create re ad and write function to module  \ndef read():  \n    print(\"Department\")  \ndef write():  \n    print(\"Student\")  \nOutput:  \n>>> from IIYEAR.CSE import student  \n>>> student.read()  \nDepartment  \n>>> studen",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 141
    },
    {
        "content": "dent\")  \nOutput:  \n>>> from IIYEAR.CSE import student  \n>>> student.read()  \nDepartment  \n>>> student.write()  \nStudent  \n>>> from IIYEAR.CSE.student import re ad \n>>> read  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 141
    },
    {
        "content": "PYTHON PROGRAMMING                                       III YEAR/II SEM                   MRCET  \n137 \n <function read at 0x03BD1070>  \n>>> read()  \nDepartment  \n>>> from IIYEAR.CSE.student import write  \n>>> write()  \nStudent  \n# Write a program to create and impo rt module?  \ndef add(a=4,b=6):  \n    c=a+b  \n    return c  \nOutput:  \nC:\\Users \\MRCET \\AppData \\Local \\Programs \\Python \\Python38 -32\\IIYEAR \\modu1.py  \n>>> from IIYEAR import modu1  \n>>> modu1.add()  \n10 \n# Write a program to create",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 142
    },
    {
        "content": "\\IIYEAR \\modu1.py  \n>>> from IIYEAR import modu1  \n>>> modu1.add()  \n10 \n# Write a program to create and rename the existing module . \n \ndef a():  \n    print(\"hello world\")  \na() \nOutput:  \nC:/Users/MRCET/AppData/Local/Programs/Python/Python38 -32/IIYEAR/exam.py  \nhello world  \n>>> import exam as ex  \nhello world  ",
        "document_name": "Demo2.pdf",
        "course_id": "pyt123",
        "page_number": 142
    }
]