Functions

Written and reviewed by Rohit Singh, Computer Science & Commerce faculty at UniDrill (MCA, Osmania University · 6 years teaching). Based on NCERT Computer Science Class XI, Chapter 7.

Why write the same code only once?

A company makes tents shaped like a cylinder with a cone on top. To fix the price it must find the canvas area of the cylinder, the canvas area of the cone, the cost, and the final amount after 18% tax. Written as one long program, the calculation works, but it is bulky, hard to read and impossible to reuse. Now suppose the company designs a tent with a rectangular base and the same cone on top. With a long program you copy and paste. With functions you simply call the cone calculation again. Splitting a program into separate, named blocks, each with one job, is called modular programming, and the function is Python's main tool for it.

What is a function?

A function is a named group of instructions that does a specific task when it is called. You write it once and call it as many times as you like, from anywhere in the program or from inside another function.

Python gives you three kinds of function, and the chapter follows this order.

Defining and calling a user defined function

A definition starts with the keyword def, then the function name, a pair of brackets holding the optional parameters, and a colon. The body is indented underneath.

The last line is the call: the function name followed by brackets. Four rules from the syntax are exam favourites. The header ends with a colon. The function name follows the same rules as any identifier. Parameters are optional, and a function may or may not return a value. Statements that are not indented under the header are not part of the function.

Flow of execution: what runs when

When Python meets a def, it only remembers the function. The body does not run. The body runs when the function is called. At a call, control jumps into the function, runs its statements, and returns to the point of the call. This is the flow of execution, and it is why you must read a program in the order of execution, not simply from top to bottom.

Worked example: order of execution.

A function must be defined before it is called. If the call line comes first, the interpreter has not yet seen the def, and the program stops with NameError: name 'helloPython' is not defined. The fix is simply to move the definition above the call.

Pause and predict: a program contains only the lines def hello(): and, indented beneath it, print("Hi"). Nothing else. What is printed when you run it?

Check your answer: nothing at all. The definition only stores the function. Without a call such as hello(), the body never runs.

Parameters, arguments and default values

A parameter is the name in the function header that receives a value. An argument is the actual value passed in the call. In sumSquares(num), num is the argument and the header def sumSquares(n): holds the parameter n. Arguments and parameters are matched in order, and an argument can be an expression, which Python evaluates before the call.

You can also give a parameter a default value, which is used when the call leaves that argument out. The rule: default parameters must be the trailing ones. If a parameter has a default, every parameter to its right must also have one.

Worked example: default values. What do the three calls return?

The result prints as 100.0 and not 100 because / always gives a float.

Returning values

A function does its work in one of two ways: it displays a result with print(), or it returns it with return. The return statement does two things: it sends control back to the caller and it hands over a value (or None if you give nothing). A function without a return statement is called a void function, and it returns None.

Because a function may or may not take arguments and may or may not return a value, there are four combinations.

Pause and predict: def f(): print("hi"). Then you run r = f() followed by print(r). What appears on the screen?

Check your answer: hi and then None. The call prints hi inside the function, but since there is no return, the value stored in r is None.

Returning more than one value. Python returns several values together as a tuple, which you can unpack in the same order.

Worked example: area and perimeter of a rectangle.

Does changing the parameter change the caller's variable? For numbers and strings, no. Reassigning a parameter makes it point to a new value, and the caller's variable is untouched.

This prints 8. At the call, n and num refer to the same value 8 (and id() shows the same number for both). But num = num + 5 creates a new value 13 and makes only num refer to it, so id(num) changes while n still refers to 8. Chapter 9 shows that a list behaves differently, because it can be changed in place.

Scope of a variable

The part of a program where a variable can be used is its scope. There are two kinds.

If a function creates a variable with the same name as a global one, the function gets its own local variable, which hides the global one. The global stays unchanged. To change the global itself from inside a function, declare it with the keyword global.

Worked example: local versus global.

The common wrong answer is 5 and 5, which assumes the function changed the global. Now add one line, global x, as the first line inside f. With it, x = 5 rebinds the global variable, so the output becomes 5 and then 5.

Beyond the textbook. For the exam: a variable assigned inside a function is local, and a global must be declared with global to be changed. In reality: Python decides whether a name is local by looking at the whole function body, not line by line. So in def k(): y = y + 1, with y global, Python treats y as local because it is assigned in the body, and then fails on the right side with UnboundLocalError because no local y exists yet. Reading a global without assigning to it works without any global keyword.

Pause and predict: a global count = 0. A function inc() contains only count = count + 1. You call inc(). What happens?

Check your answer: an error. The assignment makes count local to inc(), so the right side tries to read a local count that has no value yet. Adding global count at the top of the function fixes it.

Built in functions

Built in functions are ready made. Their code is already inside the interpreter, so no import is needed. You have already used input(), int() and print(). A quick way to understand any function is to ask: does it accept a value, and does it return one? input("Enter name: ") accepts the prompt and returns the typed text, while print() accepts values and returns nothing useful.

For negative numbers divmod uses floor division, so divmod(-7, 2) is (-4, 1), because $-4 \times 2 + 1 = -7$.

Modules and the import statement

A module is a Python file (.py) that holds a collection of function definitions. A function is a grouping of instructions, and a module is a grouping of functions. To use one, import it, then call its functions as modulename.functionname(). The from form brings in only the functions you name, and you then call them without the module name.

A module is loaded only once, however many times you import it. Module names are all lowercase, because Python is case sensitive. Importing only what you need keeps the program light.

The math module returns floats for most functions.

Ceiling and floor are opposites on the number line: the ceiling of 9.7 is 10 and the floor is 9, but for negative numbers the ceiling of -9.7 is -9 (towards zero) and the floor of -4.5 is -5 (away from zero). Do not confuse either with simply chopping off the decimal part, which is what math.trunc() does.

The random module generates random numbers.

The statistics module works on a numeric sequence.

Composition. When the output of one function becomes the input of another, you have composition. The inner call runs first. For example, sqrt(ceil(624.7)) first computes ceil(624.7), which is 625, and then sqrt(625), which is 25.0. In the same way, trunc(625.7) cuts the decimal part and gives 625, so sqrt(trunc(625.7)) is also 25.0.

Beyond the textbook. For the exam: pow(5, 2) gives 25 and math.pow(5, 2) gives 25.0, so the built in pow keeps integers as integers while math.pow always returns a float. In reality: the built in pow also accepts a third argument for modular arithmetic, pow(5, 2, 4), which is 25 mod 4, or 1. This is used widely in cryptography because it stays fast even for huge numbers.

Beyond the textbook. For the exam: the numbers from random are random. In reality: they are pseudo random: a formula produces them from a starting value, called the seed. If you fix the seed with random.seed(1), the same program prints the same "random" numbers every run, which is how programmers make a test repeatable.

Your own module. Save functions in a file such as basic_math.py, with a triple quoted docstring at the top describing the module. After import basic_math, the docstring is available as basic_math.__doc__ and the functions as basic_math.addnum(2, 5).

Exam traps

60-second revision

Where this chapter connects

• Previous: Flow of Control gives the decisions and loops that fill the body of nearly every function here.
• Next: Strings uses many functions and methods, and its programs are written as user defined functions.
• Later in this unit: Lists shows how a list behaves differently when passed to a function, and Tuples and Dictionaries explains the tuple that carries multiple return values.