Defining and calling functions

Giving a block of code a name

A function is a named block of code you can run again and again. You define it once with def, a name, parentheses and a colon; the indented block under it is the body. return sends a value back to whoever called the function. Calling it means writing its name with parentheses and the values to work on.

def gross_value(price, quantity):
    return price * quantity

print(gross_value(184.25, 200))  # 36850.0

Parameters and arguments

The names in the parentheses of def are parameters: placeholders for the inputs. The values you pass when you call are arguments, and they fill the parameters in order. Swap them and the result changes. Passing the wrong number of arguments is an error. Each call gets its own fresh copy of the parameters.

# Arguments fill the parameters in order
def spread(bid, ask):
    return ask - bid

print(spread(184.25, 184.5))  # 0.25
print(spread(184.5, 184.25))  # -0.25

return is not print

print shows something on the screen for a human. return hands a value to the calling code so it can keep working with it. A function with no return gives back None, which means "nothing". Functions that calculate should return; the code that calls them decides whether to print.

# A function with no return gives back None
def show(price):
    print("price", price)

result = show(184.25)   # price 184.25
print(result)           # None

Small functions that build on each other

A function can call other functions, so you build big behaviour from small, testable pieces. Give each function one job and a name that says it. The docstring, a string right under def, explains it to the next reader. Define a function before the line that calls it runs.

# Small functions build bigger ones
def gross_value(price, quantity):
    """Value of a position before costs."""
    return price * quantity


def commission(gross):
    """0.1% of the value, but never less than 1.0."""
    return max(1.0, gross * 0.001)


def net_cost(price, quantity):
    """What the position really costs: value plus commission."""
    gross = gross_value(price, quantity)
    return gross + commission(gross)


print(net_cost(184.25, 200))  # 36886.85

Returning several values

return a, b hands back both values at once, as a tuple: an ordered pair written with commas (tuples get their own topic soon). The caller can name the pieces straight away. Splitting an order of 1,000 shares into 3 slices with // and % returns the size of each slice and what is left over.

# return several values as a tuple
def split_fill(quantity, slices):
    return quantity // slices, quantity % slices

size, leftover = split_fill(1000, 3)
print(size, leftover)  # 333 1

• One job per function, and a name that says what it returns.
• Calculate and return; let the caller print.
• Add a docstring that says what goes in and what comes out.

Next up: function arguments and defaults, to call functions with names, optional values and any number of arguments.

Lab · what's graded

• Define a function that values a position with gross_value25 pts
• Charge a commission with a minimum using commission25 pts
• Build the real cost from two functions with net_cost25 pts
• Return two values at once with split_fill25 pts