Functions¶

Mathematical functions are rules for turning given inputs into specific outputs. For example,

\[ f(x) = x^2 \]

maps the input 4 to the output 16 and the input 9 to the output 81. Python functions are similar: they take in inputs, do specified computation, and give back outputs. Programming tasks that need to be done repeatedly, but with different inputs, are best formulated as functions.

Avoid Copy + Paste

Functions make it possible to reuse the same piece of code many times. If you find yourself copying and pasting the same chunk of code repeatedly, consider writing a function instead. This will save you time and make it easy to globally update the behavior of the reused chunk of code if needed.

Defining Functions¶

Python functions are defined with a block of code that has three main parts:

the signature,
an optional docstring, and
the body.

The following code defines a function named circle_area() for computing the area of a circle,

\[ A = \pi r^2, \]

given a radius $r$ (using the first six digits of $\pi$).

Signature

def circle_area(radius):
    """Compute the area of the circle with the given radius: A = π r^2."""
    return 3.14159 * radius**2

Docstring

def circle_area(radius):
    """Compute the area of the circle with the given radius: A = π r^2."""
    return 3.14159 * radius**2

Body

def circle_area(radius):
    """Compute the area of the circle with the given radius: A = π r^2."""
    return 3.14159 * radius**2

Signature¶

The function signature defines the name of the function and its inputs.

The keyword def begins the definition of the function.
The word following def is the name of the function. Function names must follow the same rules as variable names: start with a letter and use only letters, numbers, and underscores.
Immediately after the function name, parentheses ( and ) enclose the function parameters, the inputs. Functions can have one or many inputs, or none at all. Parameters are temporary variables within the function body.
The colon : marks the end of the function signature.

The circle_area() function has a single parameter, radius.

Lines after the signature that are indented with four spaces form the rest of the function definition. Code that is unindented is no longer part of the function definition.

Docstring¶

If the first line after the signature is a triple-quoted string, it is called the docstring. The docstring gives human-readable instructions and context about the function, its inputs, and its outputs. Like comments, docstrings do not affect the actual execution of the function.

Because circle_area() is quite simple, a single-line description suffices as the docstring.

Write Quality Docstrings

Clear, readable docstrings are extremely important if you want anyone (including your future self) to be able to read or use your code. When you define a function, always write at least a short docstring describing what the function does.

Body¶

The function body is everything after the docstring until the indentation goes back to the same level as def. The body of the function can be several lines long and is where the action happens. Within the body, the function parameters are available as temporary variables.

The body usually ends with a return statement which indicates the function output or outputs. If a function does not have a return statement, Python treats it as if the body ended in the line return None. The constant None is a placeholder indicating “no value.”

The body of circle_area() consists of a single line, the return statement. In this case, the area $\pi r^2$ is computed as a float, and this float is the function output.

More Examples¶

Signature

def cone_volume(baseradius, height):
    """Compute the volume of the cone of the given radius and height.

    Parameters
    ----------
    baseradius : float
        Radius of the circular base of the cone.
    height : float
        Height of the cone, the distance from the circular base to the point.

    Returns
    -------
    volume : float
        Volume of the specified cone.
    """
    return 3.14159 * baseradius**2 * height / 3

This block defines a function named cone_volume() with two parameters: baseradius and height.

Docstring

def cone_volume(baseradius, height):
    """Compute the volume of the cone of the given radius and height.

    Parameters
    ----------
    baseradius : float
        Radius of the circular base of the cone.
    height : float
        Height of the cone, the distance from the circular base to the point.

    Returns
    -------
    volume : float
        Volume of the specified cone.
    """
    return 3.14159 * baseradius**2 * height / 3

The docstring is several lines long and includes sections describing the inputs and outputs and their expected data types (float).

Body

def cone_volume(baseradius, height):
    """Compute the volume of the cone of the given radius and height.

    Parameters
    ----------
    baseradius : float
        Radius of the circular base of the cone.
    height : float
        Height of the cone, the distance from the circular base to the point.

    Returns
    -------
    volume : float
        Volume of the specified cone.
    """
    return 3.14159 * baseradius**2 * height / 3

The body is a single line consisting of the return statement.

Signature

def exclaim():
    """Print a very long word forward and backward."""
    print("supercalifragilisticexpialidocious!")
    print("suoicodilaipxecitsiligarfilacrepus?")

This block defines a function named exclaim(), which does not have any parameters.

Docstring

def exclaim():
    """Print a very long word forward and backward."""
    print("supercalifragilisticexpialidocious!")
    print("suoicodilaipxecitsiligarfilacrepus?")

The docstring is a brief one-line description.

Body

def exclaim():
    """Print a very long word forward and backward."""
    print("supercalifragilisticexpialidocious!")
    print("suoicodilaipxecitsiligarfilacrepus?")

The body is two lines long and does not contain a return statement, so the function always returns None.

Built-in Functions¶

Python provides several basic functions that are always available. We have already seen print(), which prints a string representation of the arguments to the screen. Here are a few other useful built-in functions.

Signature	Returns	Description
`print(arg1, ...)`	`None`	Print a string representation of each argument.
`abs(x)`	`int` or `float`	Return the absolute value of `x`, that is, $\|x\|$
`round(x)`	`int`	Round a number `x` to the nearest integer
`round(x, n)`	`int` or `float`	Round a number `x` to `n` decimal places
`divmod(a, b)`	`int`, `int`	Do integer division of $a \div b$ with a remainder

Note that print() does not return anything, abs() and round() return a single number, and divmod() returns two numbers.

x = 3 * (2**6) - 2 * (3**5)
print(x)

# Compute the absolute value of x.
print(abs(x))

-294
294

# Round a number to the nearest integer.
pi = 3.14159265358979323486264338
print(round(pi))

# Round the same number to four and eight decimal places.
print(round(pi, 4))
print(round(pi, 8))

3
3.1416
3.14159265

# Print several values on the same line.
print(pi, abs(pi), round(pi))

3.141592653589793 3.141592653589793 3

Problem 4

Recall the creamery from Problem 1 that has the following menu items.

Box of French fries, $2.49
Guacamole bacon burger, $8.69
Single scoop of ice cream, $3.99

Write a function named creamery_bill() that accepts three int arguments (in this order):

The number of boxes of French fries to order.
The number of guacamole bacon burgers to order.
The number of single scoop ice creams to order.

Calculate the total cost of the order with the given numbers of items, including the 7.45% tax and the $5.00 coupon. Return the result, rounded to the nearest cent (two decimal places).

Test Cases

print(creamery_bill(2, 2, 2))  # 2 of each
print(creamery_bill(1, 2, 3))  # 1 fries, 2 burgers, 3 ice creams
print(creamery_bill(0, 3, 5))  # 3 burgers, 5 ice creams

6
21
45

Additionally, creamery_bill(3, 2, 2) should nearly equal problem1_total (with perhaps a small difference due to rounding).

The built-in function divmod() performs integer division and returns both the quotient and the remainder.

# 131 divided by 7 is 18 with remainder 5
quotient, remainder = divmod(131, 7)
print(quotient)
print(remainder)

18
5

The following is a simplified definition for divmod().

def divmod(a, b):
    """Return the integer quotient and remainder for `a` divided by `b`."""
    return a // b, a % b

Problem 5

One inch equals 2.54 centimeters. Therefore,

\[ x~\text{centimeters} = x~\text{centimeters} \times \frac{1~\text{inch}}{2.54~\text{centimeters}} = \frac{x}{2.54}~\text{inches}. \]

There are 12 inches in a foot.

Write a function named cm2ftin() that accepts a single argument representing a length in centimeters. Convert the length to inches, round the total number of inches to the nearest whole inch, then return two values: the number of feet and the remaining inches.

Test Cases

# 2.54 centimeters = 0 feet, 1 inch
feet, inches = cm2ftin(2.54)
print(feet)
print(inches)

0
1

# 1000 centimeters = 10 meters = 32 feet, 9.7 inches
feet, inches = cm2ftin(1000)
print(feet)
print(inches)

32
10

Functions¶

Defining Functions¶

Signature¶

Docstring¶

Body¶

More Examples¶

Calling Functions¶

Scope¶

Evaluation Order¶

Multiple Return Values¶

Built-in Functions¶