Python Intermediate

NCEA Compatibility

Module: as91883 Develop a computer program

Requirements: User-defined methods, functions or procedures

Learning Outcomes

On completion of this section you will be familiar with

• The need for functions in a programme.
• How to pass arguments to a function
• How to get values back from functions.

Introduction

Listing 1 below is a reprint of one of the first programmes we wrote. It is a very simple programme that is very easy to follow since the individual lines of the input, processing and output followed each other in a very logical sequence from top to bottom. There is hardly any need for comments or documentation due to its simplicity.

                    
                        #C2Interactive Payroll Programme
                        strName=input("Enter employee's full name:  ")
                        floatHours=float(input("Enter value for hours:  "))
                        floatRate=float(input("Enter value for rate:  "))
                        floatGross=floatHours * floatRate
                        floatTax=floatGross * 0.25
                        floatNet=floatGross-floatTax
                        print("Gross is " + str(floatGross))
                        print("Tax is " + str(floatTax))
                        print("Net is " + str(floatNet))
                    
                    

Of course this programme was so simple that it was of no use in real life. In order to make it more useful we added an if..else construct in order to calculate the tax. After that we added a if..else..elif construct in order to calculate the superannuation. Finally, in order to validate the hours and rate we added two while loops, one for each value.

Recall that the if.. else construct was added to handle the complexity of the tax calculation, the if..elif..else to handle the even more complex superannuation contribution and the while loop to handle the validation of the data going into the variable floatHours. Adding these extra functionalities added to the complexity of the programme and made it difficult to read and interpret.

Our aim here is to restore the original simplicity of the programme. To do this we shall separate the processing from the main programme so that the main programme will retain the simplicity of Listing 1 above. The processing we are separating include the calculation of the gross, the tax and the net. Those are three separate processes which we shall divide up among four separate functions which we shall name calculateGross, calculateTax() and calculateNet(). We shall also create another function that will display the calculated values for the gross, tax and the net pay. We shall call this function showData().

As well as making our programme easier to read, functions have another benefit. Suppose that there was a group of program lines that were required to be used in different parts of the programme, there are two ways we can do this. One way is that we simply write out the lines of code separately for each part of the programme where they are required. This has two drawbacks:

• Firstly the more often we retype the lines of code the more likely we are to make a mistake in one of them. This would cause inconsistency in the application.
• If the routine needs to be altered then we have to make the same alteration wherever the routine occurs. This has the inherent danger that we may miss out one of the instances of the routine.

The other alternative is to write the group of lines together only once and then to call that group whenever we need to use them. This has the following advantages:

• It saves both typing time and storage space.
• As we write them only once the danger of error is minimised.
• If the routine needs to be changed then the change has to be done only once

How to create a Function

                    
                        def calculateTax(gross):
                            if gross < 500:
                                tax=gross * 0.25
                            else:
                                tax=125 + (gross-500) * 0.33
                            return tax
                    

Listing 2 above shows how a function is created.

In line 1 the function is defined using the keyword def. This is followed by the name of the function – calculateTax(), in this case. The name of the function is followed by an opening and a closing bracket and between those you can have as many parameters as you wish.

What is a parameter? A parameter is a variable that holds a value that has been passed to the function by the main programme, or by another function. In our case, once our programme has calculated the value of the gross, it calls the function calculateTax() and passes the value of the gross to it. This value will be stored in the parameter gross.

To finish off the description of the first line of code we must point out the colon at the end of the line. This colon specifies that lines 2 to 6 are subservient to line 1 or, in other words, the indented lines form the body of the function.

Lines 2 to 5 consist of an if..else construct. This construct tests the value of the parameter and if it is less than 500 the value of the local variable tax is calculated in line 3, otherwise the value of tax is calculated at line5.

Line 6 has something new for us – the keyword return. This is followed by the variable tax. Before describing this keyword we must first look at the concept of local variables.

The variable tax has been created inside the function calculateGross() and is therefore only visible inside the body of the function. This type of variable is referred to as a local variable.

Since the variable tax is local to the function calculateGross() it cannot be seen by the main programme and if we need to get the value stored variable back to the main programme we have to use the keyword return to do so.

Once we start examining the main programme we shall show you exactly how this is accomplished.

Extending the Payroll

                        #CC8 Functions.py
                        #function for calculating gross
                        def calculateGross(hours, rate):
                            gross=hours*rate
                            return gross
                        
                        #function for calculating tax
                        def calculateTax(gross):
                            if gross < 500:
                        	    tax=gross * 0.25
                            else:
                        	    tax=125 + (gross-500) * 0.33
                            return tax
                        
                        #function for calculating the net
                        def calculateNet(gross, tax):
                            net=gross - tax
                            return net
                        	
                        #function for displaying results
                        def showData(gross, tax, net):
                            print("Gross:    " + str(gross))
                            print("Tax:      " + str(tax))
                            print("Net:      " + str(net))	
                        	
                        #Main body of programme
                        
                        #input section
                        strName = input("Enter employee's full name:  ")
                        floatHours = float(input("Enter value for hours:  "))
                        floatRate = float(input("Enter value for rate:  "))
                        
                        #processing section
                        floatGross = calculateGross(floatHours, floatRate)
                        floatTax = calculateTax(floatGross)
                        floatNet = calculateNet(floatGross,floatTax)
                        
                        #output section
                        showData(floatGross,floatTax,floatNet)
                   
                    

In Listing 3 above lines 1 to 24 is the area where the programme’s functions are stored. Even though the code for the functions is at the start of the programme the same functions are not executed immediately. This is because the first line of each function defines it to be a function and Python will not run functions unless they are called from somewhere else. For this reason we have to get down as far as line 29 before we meet the first line that will be executed. This line and the two that follow it allow the user to enter values for the employee’s name, the hours worked and the hourly rate. These lines have not changed since the previous version of the programme and therefore there is no need to discuss them.

The processing section spans lines 34 to 36. In order to explain it let us assume that the user entered 20 and 30 for the hours and the rate and that therefore these values are stored in the variables floatHours and floatRate .

At line 34 the function calculateGross(floatHours, floatRate) is called This means that control will pass up to line 3 and the values 20 and 30 that were stored in the variables floatHours and floatRate are copied into the parameters hours and rate at line 3.

Once this copying is done, execution of the function begins at line 4. Here the values of hours and rate, i.e. 20 and 30, are multiplied and the result stored in the local variable gross. Thus the variable gross has 600 stored in it.

We must get this value back to the main programme. This occurs at line 5 with the code

return gross.

This causes programme control to return back to line 34 and to carry the value of the local variable gross with it. On returning to line 34 the value of gross, i.e. 600 is stored in the variable floatGross.

At line 35 the function calculateTax(floatGross) is called. This causes programme control to jump to line 8 and also causes the value stored in the variable floatGross, i.e. 600 to be copied to the parameter gross.

Once execution starts the condition at line 9 will be false since 600 is not less than 500 and therefore control will pass to line 12 where tax is calculated as

125 + (600-500) * 0.33 = 125 + 33 = 158.

Line 13 returns this value back to the variable floatTax in line 35.

Once line 35 completes processing, programme control passes to line 36 where the value of the net is calculated

The value of the net is calculated at line 36. This is done by subtracting the tax from the gross. To do this the function calculateNet(floatGross, floatTax) is called and thus control passes to line 16, where the values 600, 158 and 60 are copied into the parameters gross and tax .

At line 17 the value of the net is calculated as

600 – 158 = 442,
which is then stored in the local variable net.

At lien 18 the keyword return returns the programme control and this value back to line 36 where it is stored in the variable floatNet.

By now the processing is complete and control passes to line 39 which is the first and only line of the output section. Here the function showData(floatGross, floatTax, floatNet) is called. Control passes to line 21 where the values 600, 158 and 422 are copied into the variables gross, tax and net. Lines 22 to 24 display those values along with the appropriate labels.

Notice that there is no return keyword in function showData(). This is because the function does not perform any calculations and that its sole purpose is to present the calculated data to the user. A sample output containing the values discussed here is shown in Fig 1 below.

Before finishing this section let us take a look at the main body of the programme, i.e. lines 46 to 59. We have managed to restore the original simplicity of our original programme:

• In the input section the requests for data follow each other in logical sequence
• In the processing section the function names give a clear indication what the functions actually do, making this section self-documenting

Functions for validating Input Data

                    
                        #CC8 Functions.py
                        
                        #function for validating a floating point number
                        def validateFloat(base, top, prompt):
                            floatValue=float(input(prompt))
                            while (floatValue < float(base) or floatValue > float(top)):
                                print("Value must be in the range "+str(base) + " to " +str(top))
                                floatValue=float(input(prompt))
                            return floatValue
                        
                        #function for validating an integer
                        def validateInt(base, top, prompt):
                            intValue=int(input(prompt))
                            while (intValue < int(base) or intValue > int(top)):
                                print("Value must be in the range "+str(base) + " to " +str(top))
                                intValue=int(input(prompt))
                            return intValue
                    

Listing 4 above shows two functions for validating input data. Both functions are identical in structure and logic. The only difference between them is that the first one validates floating point numbers while the second one validates integers. They could be added to the code in Listing 3 so that the hours and hourly rate could be validated as being within allowed ranges. An example of a call to one of the functions could be:

floatHours = validateFloat(5, 60, “Enter value for hours worked”)

In this case programme control would pass to line 4 of Listing 4 where the values 5, 60 and “Enter values for hours worked” are copied into the parameters base, top and prompt.

Line 5 simply prompts the user to enter a value. The prompt would appear as follows on the console:

Enter value for hours worked :

This value entered by the user will then be stored in the local variable floatValue.

Line 6, the control line of the while loop tests the new value for being less than the parameter base or greater than the parameter top, or, in our case, being less than 5 or greater than 60. If either of those conditions is true then the body of the loop is entered.

At line 7 an error message is created by adding together the text item “Values must be in the range ”, a string version of the parameter base, the text item “ to ” and a string version of the parameter top. In our case the error message would be:

Value must be in the range 5 to 60

A line 8 the user is again prompted to enter another value and then programme control passes back to line 6.

As with all example, of the while loop this process repeats itself until the user enters a value within the range base to top or 5 – 60 in our case.

Practice

Copy Listing 3 into a .py file and run it. Check that it is working satisfactorily.

Once this is running to your satisfaction copy the code in Listing 4 and paste it into the same .py file. It does not matter where in the .py file you paste this code as long as it is not in the middle of the programme body or in the middle of another function. Now alter the line for inputting the value of hours as follows:

floatHours = validateFloat(5, 60, “Enter value for hours worked”)

Alter the line for inputting the rate in the same manner.

Once the code is running satisfactorily experiment with different lower and upper values for hours and rate and check that the altered programme applies those new limits.

Exercise

1. How does the use of functions lead to having better written programmes?
2. What does an parameters mean as far as functions are concerned?
3. What co-relation must exist between the parameters and the data passed to them?
4. Describe in detail the similarities and differences between functions and procedures

Summary

Revision

Multi choice

• What is a primary reason for using functions in a program?
  • To make programs shorter
  • To add comments easily
  • To separate processing for simplicity
  • To remove errors automatically
• What is the keyword used to define a function in Python?
  • func
  • def
  • declare
  • create
• In the context of functions, what is a parameter?
  • A variable that holds a fixed value
  • A variable that stores a value passed to a function
  • A value returned by a function
  • A keyword that ends a function
• What is a local variable in a function?
  • A variable defined inside a function and accessible only within it
  • A variable defined in the main program
  • A parameter passed to the function
  • A variable that holds the result of a function
• Which of the following functions only displays data without returning any value?
  • calculateGross()
  • calculateTax()
  • showData()
  • calculateNet()
• What is the purpose of the return keyword in Python functions?
  • To stop the execution of the program
  • To send a value back to the calling program
  • To define a new variable
  • To create a loop
• If a function is defined as def myFunc(x, y):, what are x and y?
  • Return values
  • Local variables
  • Parameters
  • Functions
• Why is it advantageous to use functions for repetitive tasks in a program?
  • It reduces the likelihood of errors
  • It makes updates easier
  • It minimizes code duplication
  • All of the above
• What happens when a function is called in Python?
  • The program skips the function
  • The program starts executing from the function definition
  • The program passes control to the function and executes its body
  • The function’s code is printed
• What type of value does the function validateFloat() ensure to accept?
  • Integer values
  • A range of floating-point numbers
  • Text input
  • Fixed values

Fill the blanks

• A function in Python is defined using the keyword ________.
• A ________ is a variable that holds a value passed to a function.
• The ________ keyword is used to send a value back to the calling program from a function.
• Variables defined inside a function are referred to as ________ variables.
• The function calculateGross(hours, rate) returns the value of ________ multiplied by ________.
• The main body of the program becomes simpler when complex processing is moved to ________.
• Functions can be called multiple times in a program, which helps in reducing ________.
• To execute the body of a function, the function must be ________.
• In def calculateTax(gross):, the parameter ________ holds the value passed to the function.
• The function showData(gross, tax, net) is responsible for ________ the calculated values to the user.

Assignment

Modify the code you have created for Assignment Part 5 as follows:

1. Put the calculation of the subtotal, GST, discount and total into three separate functions called calculateSubtotal, calculateGST, calculateDiscount, calculateTotal.
2. The function calculateSubtotal will have two arguments, the unit price and the amount sold.
3. The function calculateGST will have only one argument: the subtotal
4. The function caculateDiscount will have two arguments: the subtotal and the discount code
5. The function calculateTotal will have three arguments: the subtotal, the GSt and the discount
6. There must also be a function for printing the data called showData. This will print out the values of subtotal, GST, discount and total.

Although a major reorganization of the programme has occurred here there has been no change in the actual processing. The test data for this part will be exactly the same as that for Part 5.