Defining Functions with Parameters

A Function Name Holds a Value

A function definition does more than give a block of instructions a name. It creates a variable whose value is a function object. That function object has type function, so the function name can be inspected like other values.

def show_message():
    print("Hello")

print(show_message)
print(type(show_message))

The first print inspects the function object. The second print reports a type of function.

Calling the Function

Defining a function stores the instructions, but it does not execute the function body at that moment. To execute it, write the function name followed by parentheses. This is the same calling syntax used for built-in functions such as print(). The parentheses tell Python to execute the instructions held by the function object.

def show_message(): print("First line") print("Second line") print("Before call") show_message() print("After call")

Nested Calls and Reuse

A function can call another function. In that situation, control first moves from the original caller into the outer function. The outer function then calls the inner function. After the inner function finishes, control returns to the outer function, and after the outer function finishes, control returns to the original caller.

def print_lyrics():
    print("Line one")
    print("Line two")

def repeat_lyrics():
    print_lyrics()
    print_lyrics()

repeat_lyrics()

The body of repeat_lyrics reuses print_lyrics twice instead of duplicating the two print statements. This illustrates how larger behavior can be built from simpler functions.

List Parameters Share the Original List

When a list is passed to a function, the function receives a reference to the original list, not a copy. A parameter can therefore refer to the same list object that the caller holds. If the function performs an in-place operation on that list, the caller observes the change after the function returns.

def add_item(items): items.append("new") values = ["old"] add_item(values) print(values)

Mutation Versus New Lists

def remove_first_in_place(items):
    del items[0]

def without_first(items):
    return items[1:]

The first function changes the list received from its caller by using del. The second uses slicing, which creates a new list, and returns that new list. The caller can preserve the original while storing the returned result separately.

Mistakes with List Parameters

• Assuming that passing a list automatically passes a copy.

  A list argument gives the function a reference to the original list, so an in-place operation affects the caller's list.

  Fix: Treat append and del as changes to the shared original list. Use + or slicing and return the result when the original should be preserved.

• Treating append and + as equivalent.

  append modifies the existing list, while + creates a new list.

  Fix: Decide whether the function should mutate the caller's list or return a separate list before choosing the operation.

• Expecting a function body to run when the function is defined.

  The definition creates the function object; the body runs when the function is called.

  Fix: Use show_message() to execute the function body.

• Forgetting the parentheses when calling a function.

  The name by itself refers to the function object. Parentheses are the call syntax that tells Python to execute it.

  Fix: Write the function name followed by parentheses when you want to call it.

Practice the Execution Trace

Key Takeaways

1. Defining a function creates a variable holding a function object whose type is function.
2. A custom function is called with its name followed by parentheses, just like a built-in function.
3. A call moves control into the function body, and completion returns control to the caller.
4. A list parameter refers to the original list, so append and del can change the caller's list.
5. Use in-place operations when changing the original is intentional; use + or slicing and return a new list when preserving the original is important.