List Methods: sort(), append(), and Other Modifiers

Aliasing means two variables point to the same list object, so changes through one variable affect the other.

Programming

One List, Two Names

List modifiers can change the list that already exists. The important question is not only which variable you use, but also whether another variable refers to that same list. When two variables point to one list object, changing the list through either variable affects what the other variable sees. This situation is called aliasing.

What happens to both variables when two names point to the same list and one variable mutates it?

Tracing a Shared Reference

python

items = [3, 1, 2]
other_name = items
items.append(4)

items = [3, 1, 2]
other_name = items
items.append(4)

Output

After the append operation, the list referred to by items contains [3, 1, 2, 4]. Because other_name refers to that same list, it also sees [3, 1, 2, 4].

The assignment to other_name does not create an independent list in this example. It gives a second variable access to the same list object. append() modifies that shared list, so the change is visible through both names. The same reasoning applies to other list modifiers: first ask whether the operation changes the existing list, and then ask whether another variable shares it.

What do you think happens?

If items and other_name refer to the same list, what will other_name see after items.append(4)?

The original list without 4
A separate list containing only 4
The shared list with 4 added
No list at all

Reveal answer

Answer:

The shared list with 4 added

Aliasing means both variables point to the same list object. A change through one variable affects the other.

Separating a List with Slicing

When you need a list that can be changed without changing the original, create a defensive copy. The source pattern for this is orig = t[:]. The sliced result is an independent list, so a modifier applied to the copy can be used safely when preserving the original data matters.

How does copy = original[:] create a separate list object, and what changes when only the copy is modified?

Code walkthrough

original = [3, 1, 2]
copy = original[:]
copy.append(4)

1
original starts as the list whose data should be preserved.
2
copy = original[:] creates an independent list from the contents of original.
3
copy.append(4) modifies copy, not original.

Output

original remains [3, 1, 2]; copy becomes [3, 1, 2, 4].

Choosing a Sorting Tool

What is the difference between the new list returned by sorted(original) and the in-place change caused by original.sort()?

Choice	Effect on the original list	Use when
sorted(original)	Does not modify the original	You need a new sorted list and want to preserve the original
original.sort()	Sorts the list being modified	You want to modify a list, often after creating a defensive copy

The central distinction is whether the original list is preserved or modified.

Worked example

Preserving Data While Sorting

You have a list named scores and need sorted values without changing scores.

1
Choose sorted()
Use sorted(scores) when the original list must remain unchanged and you want a new sorted list.
2
Choose a defensive copy
Alternatively, create a copy with scores_copy = scores[:] and use sort() on the copy.
3
Check the naming
Do not name a variable sorted, because that shadows the built-in sorted function.

Result

Use sorted() directly for a new sorted list, or copy first when you specifically want to use sort() without changing the original.

Practical Mutation Checks

When a list changes unexpectedly, trace every variable that may refer to it. Compare the names involved, identify where a modifier such as append() or sort() was used, and decide whether the operation was intended to affect the existing list. If the original must be protected, create the defensive copy before modifying the working version.

A useful detection strategy is to test the behavior of the two names: make a controlled change through one name and observe whether the other name reflects it. If both views change together, the names are behaving as aliases for one list. If the second view remains unchanged after a copy is made, the lists have been separated for the purpose of that modification.

Frequent Reference Mistakes

Common mistake
Assuming a second variable automatically contains an independent list
What it looks like
```
other_name = items followed by items.append(4)
```
Why it fails
Aliasing means both variables can point to the same list object, so the modification is visible through both names.
Do this instead
Use a defensive copy such as other_name = items[:] when the second list must be modified independently.
Common mistake
Using sort() when the original list must be preserved
What it looks like
Calling original.sort() while still needing the original ordering
Why it fails
The sort() method changes the list being operated on.
Do this instead
Use sorted(original), or copy the list first and sort the copy.
Common mistake
Treating sorted() and sort() as interchangeable
What it looks like
Choosing a sorting operation without deciding whether a new list or an in-place change is wanted
Why it fails
sorted() produces a new sorted list without modifying the original, while sort() is used to modify the list.
Do this instead
Choose based on whether the original data must remain unchanged.
Common mistake
Naming a variable sorted
What it looks like
```
sorted = some_list
```
Why it fails
The name sorted shadows the built-in function.
Do this instead
Choose another variable name so sorted() remains available.

Apply the Choice

MEDIUM

A program has a list named tasks. You need a working version that can be modified and sorted while keeping the original task order available. Explain whether you would use a second direct reference, a slice, sorted(), or sort() on a copy. Justify your choice.

Hints

Ask whether the original list must remain unchanged.
A second name pointing to the same list can create aliasing.
A slice creates the defensive copy described in this lesson.
Use sorted() when you want a new sorted list without modifying the original.

Your attempt (not saved)

EASY

Predict the result conceptually: one variable refers to a list, a second variable is assigned directly from the first, and append() is used through the second variable. Which variable views the changed list? Then describe how slicing would change the situation.