How Do You Define Functions in Python?

A function is defined with the def keyword, followed by a name, a list of parameters in parentheses, and a colon. The body of the function is indented underneath it.

def greet(name, greeting='Hello'):
    return greeting + ', ' + name + '!'


print(greet('Ada'))                          # Hello, Ada!
print(greet('Ada', greeting='Hi'))           # Hi, Ada!


def no_return(value):
    print('inside:', value)


result = no_return(42)
print('returned:', result)                   # returned: None

The first function takes one required parameter and one that has a default value. The second function prints something and returns nothing, so the assignment binds the result to None. That is the most common surprise for newcomers, because a function that forgets to return quietly produces None instead of raising an error.

Two details about the definition itself are worth knowing. The def statement does not run the body. It creates a function object and binds the name to it, so you may define a function after another function that calls it, as long as the call happens after the definition has run. And the body of a function cannot see the local variables of the caller, which is one of the things that keeps functions easy to test.

The def keyword and the parentheses are both required by the grammar, unlike some languages where a function without parameters can be written without them. The structure also makes the return value obvious, because everything after return is a single expression. You cannot return two statements, but you can return two values inside one tuple.

The difference is that print writes to the output stream and gives nothing back, while return hands a value back to the caller. Only one of those two lets the caller do anything with the result.

def shout_print(text):
    print(text.upper())


def shout_return(text):
    return text.upper()


shout_print('hello')
# HELLO                 <- printed, but the value is gone

result = shout_return('hello')
# nothing is printed here
print(result)             # HELLO

# This is the reason to prefer returning over printing.
print(shout_return('hello') + '!')   # HELLO!

The last line is the argument in favour of returning instead of printing. A function that returns a value can be stored, compared, passed to another function, or used inside a larger expression. A function that prints can only be seen by whoever is watching the output stream, which makes it impossible to test, impossible to reuse, and impossible to put inside a library without filling the caller's terminal with noise.

The rule of thumb is that a function should work out a value and return it, and the caller should decide what to do with that value. The exceptions are genuinely interactive programs, such as a command-line tool that is supposed to print a report or a script whose whole job is to write output, where printing in the top-level code is the right design.

One more detail is worth naming. A function that both prints and returns is harder to reason about, because now there are two ways for information to leave it. If you find yourself doing that, split it into a function that returns a value and a caller that prints it.

The def keyword makes the intent clear at the exact point where you write it. Python uses indentation to show blocks, so without a keyword a function header could be confused with other kinds of statement, and the grammar would have to guess what such a line meant. Making it explicit costs three characters and removes the guesswork completely. The same argument applies to return. Python has no implicit return value, so a function that never reaches a return statement gives back None, and writing the return yourself documents that on purpose.

Default arguments are where the real contract questions live. A default is a value that is fixed when the def statement runs, and that means it is shared by every call that leaves the argument out. For an immutable default such as a number or a string, that is harmless. For a mutable default such as a list, it is the classic bug, because the list is created once and every call that omits the argument changes that same list. The standard fix is to default the parameter to None and build the container inside the body of the function.

# The version with a bug in it.
def add_item(item, bucket=[]):
    bucket.append(item)
    return bucket


# The safe version.
def add_item(item, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket

There is a related subtlety with keyword arguments and ordering. Parameters that have defaults must come after parameters that do not, and a caller who mixes positional and keyword arguments must not repeat a parameter. Once a function has several parameters of the same type, calling it by keyword is usually clearer and safer than trying to remember the order.

The strongest answer to give in an interview is that a function signature is a contract. The parameter names, the order, which parameters have defaults, and which ones are keyword-only all shape how the function can be called safely. Changing the order of the parameters in a later release breaks every caller, which is the reason that keyword-only arguments were added to Python in the first place.