In this lesson we show you the most important idea in programming: defining your own functions! Functions let your program become shorter, better-organized, easier to read, easier to debug, and more reusable. In later lessons we will see other benefits like recursion.

Defining a Function

We'll start with an example. Remember the function abs? It takes one argument (a number x), and returns its absolute value (which is x when x ≥ 0, and -x when x < 0). The way to define this function in Python is:

def abs(x):     # define a function named 'abs' of one argument named 'x'
  if x >= 0:    # function body starts here
    return x
  else:
    return -x   # function body ends here

(Click here to test this code in the console.)

The Two Parts of a Function Definition

The first line in a function definition specifies the name of the function and the arguments of the function. It should look like

def «function-name»(«argument-list»):

In the example above, abs was the function name, and the argument list was x. It is called an argument list because there can be multiple arguments such as x, y, z; it's also possible to have zero arguments, i.e. an empty list. The arguments are the input(s) to the function.

Everything after the first line of a function definition is the body of the function. The body is an indented block of code. Whenever the function is called, the body is executed on those arguments/inputs. Finally, when we reach this line in the function body,

return «value»

the function stops running and returns «value» as its output. That is, the return value is the output of the function. As the abs example shows, the body may contain several return statements; but only the first one executed has an effect since the function stops executing afterwards.

Example: Defining and Calling a Function

The following program contains a function definition and some other statements that are executed after the function is defined. 

Example

Squaring function

def square(x): # function definition return x*x # the body only has one line. # use the function, now that it's defined print(square(10)) print(square(square(2)))

We see that the function name is square, there is just one argument x, and that the function body consists of just one line return x*x. Then outside of the function we have two commands, which call the function a total of three times.

1. When the first command is executed, Python must evaluate square(10).
   • Python compares the list of inputs (10) to the argument list (x). So, it executes the function body return x*x while remembering that x equals 10. Thus x*x yields 100, which is printed.
2. When the second command is executed, Python must evaluate square(square(2)).
   • The inner part square(2) is evaluated first. We temporarily set x equal to 2 and run the function body, which returns 4.
   • Then the outer expression is evaluated; since square(2) gave 4, we are now calling square(4). This returns 16, which is printed.

As usual, you may want to see what this looks like in the Python3 Visualizer.

Four Common Mistakes

One common mistake you can make in defining a function is to forget the return statement.

Example

Mistake 1: forgetting to return

def square(x): x*x print(square(10))

As you can see, if no return statement is encountered in the body, then the function gives None by default. So, if you are failing some exercise because a function is returning None, the problem is often that some function inputs are not causing a return statement to be executed.

You may also intentionally omit a return statement. This only makes sense if your function has some side effect other than its return value, for example printing some output: Example: A side effect and no return statement def repeatedPrint(string, repetitions): # no returns in this function for i in range(0, repetitions): print(string) repeatedPrint('Hello, world!', 3)

Another common mistake is forgetting to indent the code, resulting in an IndentationError.

Example

Mistake 2: forgetting to indent

def square(x): return x*x print(square(10))

As we saw in lesson 2, calling with too few or too many arguments causes an error.

Example

Mistake 3: call with too many arguments

def square(x): return x*x print(square(7, 11))

Finally, if you make a typo when defining or calling the function, you will get an error saying that the function is undefined.

Example

Mistake 4: wrong name

def square(x): return x*x print(skware(10))

Try it Yourself

Coding Exercise: Cubism

Define a function cube(n), which takes a single number n as input, and outputs its cube n × n × n.

You need to create an account and log in to ask a question.

# delete this comment and enter your code here

Enter testing statements like print(myfunction("test argument")) below.

More actions... History Help

Two or More Arguments

The functions above only took one argument, but a function can be designed to take any number of arguments. For example, you have been calling input() with 0 arguments (and you'll define a function with zero arguments in lesson 15A).

Here's an example with two arguments, about geometry. Suppose we need a function to compute the area of a triangle, given the length of its base and its height. The formula for the area is

area = base × height / 2

Then in Python, we can define a function triangleArea as follows:

Example

A function with two arguments

def triangleArea(base, height): return base*height/2 print(triangleArea(3, 5)) print(triangleArea(4, 2))

As you can see, the only change is that we replaced def «function-name»(«argument1») with def «function-name»(«argument1», «argument2»).

In the last exercise we ask you to write your own function of two arguments, to compute the perimeter of a rectangle. (The perimeter is the total length of all sides.) In a rectangle with a given width and height, its perimeter is given by the following formula:

perimeter = width + height + width + height

Coding Exercise: Rectangle

Define a function rectanglePerimeter(width, height), which computes the perimeter of a rectangle.

You need to create an account and log in to ask a question.

# delete this comment and enter your code here

Enter testing statements like print(myfunction("test argument")) below.

More actions... History Help

Functions Calling Functions

Functions are the building blocks of well-built large programs: you can do the same task twice without writing out the same code twice, and you can re-use solutions to common tasks. Here is an example of building one function and using it inside of another one.

Example

Can you guess what this program does, before you run it?

Remember from lesson 4 that multiplication of strings and integers means to repeat the string that many times. For example, "tar"*2 is "tartar".

def inner(string, width): return string + " " * (width - len(string)) def outer(string1, string2): w = max(len(string1), len(string2)) print("*" * (w + 4)) print("* " + inner(string1, w) + " *") print("* " + inner(string2, w) + " *") print("*" * (w + 4)) outer("Box number one", "is very fun") outer("Box #2", "(not False) is " + str(not False))

You are now ready for the next lesson!