Function Parameters and Scope

One List, Two Variables

When a list is passed to a function, the function parameter can refer to the same list object that the caller's variable refers to. The important question is what the function does next. If the function changes the existing list object with an in-place method, the caller can see that change. If the function reassigns the parameter to a new list, the caller's variable continues to refer to the original list.

Tracing a Slice Reassignment

def remove_first(t): t = t[1:] numbers = [7, 8, 9] remove_first(numbers)

Mutation and New Lists

List operations fall into two useful groups. In-place methods operate on the existing list object. Methods such as append() and pop() modify that object, so a caller can see the result when the function parameter refers to the caller's list. Other operations create a new list. Slicing and the + operator create new lists, leaving the original list unchanged unless the new result is assigned back to the caller's variable or returned and used.

Choosing the Function’s Effect

def remove_first_in_place(items):
    items.pop(0)


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

numbers = [7, 8, 9]
remove_first_in_place(numbers)
print(numbers)

numbers = [7, 8, 9]
remaining = without_first(numbers)
print(numbers)
print(remaining)

[8, 9]
[7, 8, 9]
[8, 9]

Two Lists After a Return

A function can create a new list with slicing and return it. In that case, the caller may keep both the original list and the returned list. The original remains available through the caller's variable, while the returned value refers to the newly created list. This is different from assigning a slice only to a local parameter and then discarding it when the function ends.

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

original = [4, 5, 6]
result = after_first(original)
print(original)
print(result)

[4, 5, 6]
[5, 6]

Common Mistakes

• Assuming that t = t[1:] edits the caller's list

  Slicing creates a new list, and the assignment changes only the local parameter.

  Fix: Use an in-place method such as pop() when the function should change the supplied list, or return the slice when the function should create a result.

• Using an in-place method when the original list should remain unchanged

  append() modifies the actual list object, so the caller can see the change.

  Fix: Create and return a new list when preservation of the original is part of the function's purpose.

• Creating a new list but not returning it

  The new list is assigned to a local parameter and is not made available to the caller.

  Fix: Return the new list and assign the returned value in the caller when that result is needed.

Practice the Decision

Key Takeaways

1. A function parameter is a local variable that can initially refer to the same list object as the caller's variable.
2. Reassigning a parameter to a slice changes the local parameter and does not modify the original list.
3. Methods such as append(), pop(), remove(), and extend() modify the existing list object, making their effects visible to the caller.
4. Slicing and the + operator create new lists, so return the new list when the caller needs it.
5. Choose in-place modification or a returned new list according to the function's purpose, and make that choice clear through naming and documentation.