Download to read offline
unit 4 error handling in python programming
- 1. Unit 3 -Functions A function is a block of organized and reusable program code that performs a specific, single, and well-defined task. A function provides an interface for communication in terms of how information is transferred to it and how results are generated.
- 2. Need for Functions Simplifies program development by making it easy to test separate functions. Understanding programs becomes easier. Libraries contain several functions which can be used in our programs to increase the productivity. By dividing a large program into smaller functions, different programmers can work on different functions. Users can create their own functions and use them in various locations in the main program.
- 3. Functions A functiondefinition consists of a function header that identifies the function, followed by the body of the function. The body of a function contains the code that is to be executed when a function is called. To define a function, we have to remember following points:
- 4. Defining Functions Functiondefinition starts with the keyword def The keyword def is followed by the function name and parentheses. After parentheses, a colon (:) should be placed. Parameters or arguments that the function accepts should be placed inside the parentheses. A function might have a return statement. The function code should indented properly.
- 5. Defining and Callinga Function Functions are given names Function naming rules: Cannot use key words as a function name Cannot contain spaces First character must be a letter or underscore All other characters must be a letter, number or underscore Uppercase and lowercase characters are distinct
- 6. Defining and Callinga Function (cont’d.) Function name should be descriptive of the task carried out by the function Often includes a verb Function definition: specifies what function does def function_name(): statement statement
- 7. Defining and Callinga Function (cont’d.) Function header: first line of function – Includes keyword def and function name, followed by parentheses and colon Block: set of statements that belong together as a group – Example: the statements included in a function
- 8. Defining and Callinga Function (cont’d.) Call a function to execute it When a function is called: Interpreter jumps to the function and executes statements in the block Interpreter jumps back to part of program that called the function Known as function return
- 9. Defining and Callinga Function (cont’d.) • main function: called when the program starts Calls other functions when they are needed Defines the mainline logic of the program
- 10. Designing a Programto Use Functions • In a flowchart, function call shown as rectangle with vertical bars at each side Function name written in the symbol Typically draw separate flow chart for each function in the program • End terminal symbol usually reads Return • Top-down design: technique for breaking algorithm into functions
- 11. Designing a Programto Use Functions (cont’d.) • Hierarchy chart: depicts relationship between functions AKA structure chart Box for each function in the program, Lines connecting boxes illustrate the functions called by each function Does not show steps taken inside a function • Use input function to have program wait for user to press enter
- 12. Designing a Programto Use Functions (cont’d.)
- 13. Local Variables • Localvariable: variable that is assigned a value inside a function Belongs to the function in which it was created • Only statements inside that function can access it, error will occur if another function tries to access the variable • Scope: the part of a program in which a variable may be accessed For local variable: function in which created
- 14. Local Variables (cont’d.) •Local variable cannot be accessed by statements inside its function which precede its creation • Different functions may have local variables with the same name Each function does not see the other function’s local variables, so no confusion
- 15. Passing Arguments to Functions •Argument: piece of data that is sent into a function Function can use argument in calculations When calling the function, the argument is placed in parentheses following the function name
- 16. Passing Arguments to Functions(cont’d.)
- 17. Passing Arguments to Functions(cont’d.) • Parameter variable: variable that is assigned the value of an argument when the function is called The parameter and the argument reference the same value General format: def function_name(parameter): Scope of a parameter: the function in which the parameter is used
- 18. Passing Arguments to Functions(cont’d.)
- 19. Passing Multiple Arguments • Pythonallows writing a function that accepts multiple arguments Parameter list replaces single parameter • Parameter list items separated by comma • Arguments are passed by position to corresponding parameters First parameter receives value of first argument, second parameter receives value of second argument, etc.
- 20.
- 21. Making Changes to Parameters •Changes made to a parameter value within the function do not affect the argument Known as pass by value Provides a way for unidirectional communication between one function and another function • Calling function can communicate with called function
- 22. Making Changes to Parameters(cont’d.)
- 23. Making Changes to Parameters(cont’d.) The value variable passed to the change_me function cannot be changed by it
- 24. Keyword Arguments • Keywordargument: argument that specifies which parameter the value should be passed to Position when calling function is irrelevant General Format: function_name(parameter=value) • Possible to mix keyword and positional arguments when calling a function Positional arguments must appear first
- 25. Global Variables and GlobalConstants • Global variable: created by assignment statement written outside all the functions Can be accessed by any statement in the program file, including from within a function If a function needs to assign a value to the global variable, the global variable must be redeclared within the function • General format: global variable_name
- 26. Global Variables and GlobalConstants (cont’d.) • Reasons to avoid using global variables: Global variables making debugging difficult • Many locations in the code could be causing a wrong variable value Functions that use global variables are usually dependent on those variables • Makes function hard to transfer to another program Global variables make a program hard to understand
- 27. Global Constants • Globalconstant: global name that references a value that cannot be changed Permissible to use global constants in a program To simulate global constant in Python, create global variable and do not re-declare it within functions
- 28. Introduction to Value- ReturningFunctions: Generating Random Numbers • void function: group of statements within a program for performing a specific task Call function when you need to perform the task • Value-returning function: similar to void function, returns a value Value returned to part of program that called the function when function finishes executing
- 29. Standard Library Functions andthe import Statement • Standard library: library of pre-written functions that comes with Python Library functions perform tasks that programmers commonly need • Example: print, input, range • Viewed by programmers as a “black box” • Some library functions built into Python interpreter To use, just call the function
- 30. Standard Library Functions andthe import Statement (cont’d.) • Modules: files that stores functions of the standard library Help organize library functions not built into the interpreter Copied to computer when you install Python • To call a function stored in a module, need to write an import statement Written at the top of the program Format: import module_name
- 31. Standard Library Functions andthe import Statement (cont’d.)
- 32. Generating Random Numbers • Randomnumber are useful in a lot of programming tasks • random module: includes library functions for working with random numbers • Dot notation: notation for calling a function belonging to a module Format: module_name.function_name()
- 33. Generating Random Numbers (cont’d.) •randint function: generates a random number in the range provided by the arguments Returns the random number to part of program that called the function Returned integer can be used anywhere that an integer would be used You can experiment with the function in interactive mode
- 34.
- 35.
- 36. Generating Random Numbers (cont’d.) •randrange function: similar to range function, but returns randomly selected integer from the resulting sequence Same arguments as for the range function • random function: returns a random float in the range of 0.0 and 1.0 Does not receive arguments • uniform function: returns a random float but allows user to specify range
- 37. Random Number Seeds •Random number created by functions in random module are actually pseudo- random numbers • Seed value: initializes the formula that generates random numbers Need to use different seeds in order to get different series of random numbers • By default uses system time for seed • Can use random.seed() function to specify desired seed value
- 38. Writing Your OwnValue- Returning Functions • To write a value-returning function, you write a simple function and add one or more return statements Format: return expression • The value for expression will be returned to the part of the program that called the function The expression in the return statement can be a complex expression, such as a sum of two variables or the result of another value- returning function
- 39. Writing Your OwnValue- Returning Functions (cont’d.)
- 40. How to UseValue- Returning Functions • Value-returning function can be useful in specific situations Example: have function prompt user for input and return the user’s input Simplify mathematical expressions Complex calculations that need to be repeated throughout the program • Use the returned value Assign it to a variable or use as an argument in another function
- 41. Using IPO Charts •IPO chart: describes the input, processing, and output of a function Tool for designing and documenting functions Typically laid out in columns Usually provide brief descriptions of input, processing, and output, without going into details • Often includes enough information to be used instead of a flowchart
- 42. Using IPO Charts(cont’d.)
- 43. Returning Strings • Youcan write functions that return strings • For example:
- 44. Returning Boolean Values •Boolean function: returns either True or False Use to test a condition such as for decision and repetition structures • Common calculations, such as whether a number is even, can be easily repeated by calling a function Use to simplify complex input validation code
- 45. Returning Multiple Values In Python, a function can return multiple values Specified after the return statement separated by commas Format: return expression1, expression2, etc. When you call such a function in an assignment statement, you need a separate variable on the left side of the = operator to receive each returned value
- 46. The math Module •math module: part of standard library that contains functions that are useful for performing mathematical calculations Typically accept one or more values as arguments, perform mathematical operation, and return the result Use of module requires an import math statement
- 47.
- 48. The math Module (cont’d.) The math module defines variables pi and e, which are assigned the mathematical values for pi and e Can be used in equations that require these values, to get more accurate results Variables must also be called using the dot notation Example: circle_area = math.pi *radius**2
- 49. Storing Functions in Modules •In large, complex programs, it is important to keep code organized • Modularization: grouping related functions in modules Makes program easier to understand, test, and maintain Make it easier to reuse code for multiple different programs • Import the module containing the required function to each program that needs it
- 50. Storing Functions inModules (cont’d.) • Module is a file that contains Python code Contains function definition but does not contain calls to the functions • Importing programs will call the functions • Rules for module names: File name should end in .py Cannot be the same as a Python keyword • Import module using import statement
- 51. Menu Driven Programs •Menu-driven program: displays a list of operations on the screen, allowing user to select the desired operation List of operations displayed on the screen is called a menu • Program uses a decision structure to determine the selected menu option and required operation Typically repeats until the user quits
- 52. Turtle Graphics: Modularizing Codewith Functions • Commonly needed turtle graphics operations can be stored in functions and then called whenever needed. • For example, the following function draws a square. The parameters specify the location, width, and color. def square(x, y, width, color): turtle.penup() # Raise the pen turtle.goto(x, y) # Move to (X,Y) turtle.fillcolor(color) # Set the fill color turtle.pendown() # Lower the pen turtle.begin_fill() # Start filling for count in range(4): # Draw a square turtle.forward(width) turtle.left(90) turtle.end_fill() # End filling
- 53. Turtle Graphics: Modularizing Codewith Functions • The following code calls the previously shown square function to draw three squares: square(100, 0, 50, 'red') square(-150, -100, 200, 'blue') square(-200, 150, 75, 'green')
- 54. Turtle Graphics: Modularizing Codewith Functions • The following function draws a circle. The parameters specify the location, radius, and color. def circle(x, y, radius, color): turtle.penup() # Raise the pen turtle.goto(x, y - radius) # Position the turtle turtle.fillcolor(color) # Set the fill color turtle.pendown() # Lower the pen turtle.begin_fill() # Start filling turtle.circle(radius) # Draw a circle turtle.end_fill() # End filling
- 55. Turtle Graphics: Modularizing Codewith Functions • The following code calls the previously shown circle function to draw three circles: circle(0, 0, 100, 'red') circle(-150, -75, 50, 'blue') circle(-200, 150, 75, 'green')
- 56. Turtle Graphics: Modularizing Codewith Functions • The following function draws a line. The parameters specify the starting and ending locations, and color. def line(startX, startY, endX, endY, color): turtle.penup() # Raise the pen turtle.goto(startX, startY) # Move to the starting point turtle.pendown() # Lower the pen turtle.pencolor(color) # Set the pen color turtle.goto(endX, endY) # Draw a square
- 57. Turtle Graphics: Modularizing Codewith Functions • The following code calls the previously shown line function to draw a triangle: TOP_X = 0 TOP_Y = 100 BASE_LEFT_X = -100 BASE_LEFT_Y = -100 BASE_RIGHT_X = 100 BASE_RIGHT_Y = -100 line(TOP_X, TOP_Y, BASE_LEFT_X, BASE_LEFT_Y, 'red') line(TOP_X, TOP_Y, BASE_RIGHT_X, BASE_RIGHT_Y, 'blue') line(BASE_LEFT_X, BASE_LEFT_Y, BASE_RIGHT_X, BASE_RIGHT_Y, 'green')