Concepts / Tuples and Immutability

Tuples and Immutability

Strings and tuples are immutable types in this discussion, so an operation on them creates a new object rather than changing the original object in place.

  • Programming

One Operation, Two Kinds of Change

Python operations do not all handle data in the same way. A list can be changed in place, while a string or tuple is immutable. That difference affects both the original object and any other variable referring to it. It also affects what an operation returns. The key question is not only “What value does this operation produce?” but also “Did the original object change?”

What do you think happens?

Suppose two variables refer to the same list. If the list is changed through one variable, what will the other variable show?

  • The other variable still shows the old list

  • The other variable shows the changed list

  • The other variable becomes None

Reveal answer
Answer:

The other variable shows the changed list.

Both variables refer to the same list object. An in-place list method changes that object, so every reference to it observes the change.

Following a List Through an In-Place Change

[1, 2, 3]list objectmylistrefers to the listappend(4)in-place method[1, 2, 3, 4]same list objectmylistrefers to the changed listNonemethod resultrefers toreceiveschangesstill refers toreturns
What changes when append modifies a list, and what value does append return?
Code walkthrough
numbers = [1, 2, 3]
result = numbers.append(4)

numbers
result
  1. 1
    The list starts as [1, 2, 3].
  2. 2
    numbers.append(4) adds 4 to the original list rather than creating a separate list for the result.
  3. 3
    The name numbers still refers to that list, now containing [1, 2, 3, 4].
  4. 4
    The name result receives None because append returns None.
  • numbers refers to a list containing three values.
  • append(4) changes that list in place.
  • The changed list is visible through numbers.
  • The method result is None.
Output
[1, 2, 3, 4]
None
Key point

An in-place method changes the original list object. It does not produce a new list that must be assigned back to the variable. Methods such as append() and sort() return None after making their changes.

Methods and Dotted Notation

A method is a function defined specifically for a class. When you have a list object, you access its methods with dotted notation: the object comes first, followed by a dot and the method name. In mylist.append(item), append is associated with the list class and operates in the context of mylist. A standalone function is not tied to a particular object in this way.

mylistlist objectappendmethod of listmylist.append(item)dotted notationappendstandalone functionappend(mylist, item)not the list method formprovidesused ascalled as
How does control flow differ when an operation uses dotted notation on an object instead of being called as a standalone function?
my_listlist objectlistclassappendavailable methodis an object ofdefines
How does Python determine which method to use when my_list.append(...) is evaluated?
python

The expression my_list.sort() uses dotted notation because sort is a method available for list objects. The method changes my_list directly. This is different from imagining sort as a general operation that returns a separate list.

Lists, Strings, and Tuples

listmutablein-place changeoriginal list changesstringimmutablenew stringoperation produces a newobjecttupleimmutablenew tuplethe original tuple cannotbe changedcan be modified asoperation createsreplacement requires
What happens to the original object when a list or string is changed, and when is a new object created instead?

Mutable objects can be modified in place. Lists are mutable, so methods such as append() and sort() change the original list. Immutable objects cannot be changed after they have been created. Strings and tuples are immutable types in this discussion, so an operation on them creates a new object rather than changing the original object in place.

TypeCan the original object change in place?What should you expect from an operation?
ListYesThe original list can be modified directly; in-place methods return None.
StringNoAn operation creates a new string rather than changing the original string.
TupleNoThe original tuple cannot be changed; an operation must produce a different object when a changed value is needed.

The central distinction is whether the original object can be modified in place.

(1, 2, 3)original tuplechange valuecannot modify originaltuple(1, 2, 3)original remains unchanged(1, 4, 3)different tuplecannot be modified byleavesrequires creating
What can and cannot change inside a tuple after it has been created?

Shared References

Worked example

Two Names for One List

Consider two variables that refer to the same list. What happens after the list is modified through one variable?

  1. 1
    Create the list

    A list contains [1, 2, 3], and one variable refers to it.

  2. 2
    Create another reference

    A second variable is assigned to the first variable, so both variables refer to the same list object.

  3. 3
    Modify through one reference

    Calling append(4) changes the shared list in place.

  4. 4
    Inspect both references

    Both variables show [1, 2, 3, 4] because both still refer to the changed list.

Result

An in-place modification is visible through every variable that refers to the same list.

python
Output
[1, 2, 3, 4]

This same issue can appear when a list is passed to a function. If the function modifies the list, the original list in the calling code is also modified. That behavior follows from the shared reference to the mutable list object.

Finding List Methods

When you do not remember which operations a list supports, use help(list). The help() function displays documentation for the list class, including the methods available for list objects and information about what those methods do.

python
Key point

Treat help(list) as a discovery tool. It lets you inspect the list class instead of guessing method names or assuming that a list operation behaves like a string operation.

Mistakes with Mutability

  • Common mistake

    Assuming append() returns the changed list

    What it looks like
    updated = numbers.append(4)
    Why it fails

    append() changes numbers in place and returns None.

    Do this instead

    Call numbers.append(4), then use numbers as the changed list.

  • Common mistake

    Assuming a second variable holds an independent copy

    What it looks like
    first = [1, 2, 3]; second = first; first.append(4)
    Why it fails

    Both variables refer to the same list object.

    Do this instead

    Remember that changing the list through either variable affects the shared object.

  • Common mistake

    Treating a list method like a standalone function

    What it looks like
    append(my_list, 4)
    Why it fails

    The list operation is accessed as a method through dotted notation.

    Do this instead
    Use my_list.append(4).
  • Common mistake

    Expecting strings and tuples to change in place like lists

    What it looks like

    A learner expects an operation on a string or tuple to modify the original object.

    Why it fails

    Strings and tuples are immutable types.

    Do this instead

    Expect a new object when a changed string or tuple value is needed.

Check Your Understanding

EASY

Explain what happens in this sequence: a list is assigned to first, second is assigned to first, and then second.append(9) is called. State what first refers to afterward and what value append returns.

Hints
  • Ask whether first and second refer to one list or two separate lists.
  • Recall that append changes a list in place.
  • Recall the return value of an in-place list method.
MEDIUM

Use help(list) to inspect the list class. Find a method that changes a list in place and describe whether it changes the original list, returns a new list, or returns None.

Hints
  • Begin by evaluating help(list).
  • Look for the method descriptions in the list documentation.
  • Compare the method's effect with the behavior of append() or sort().

Working Rules

  1. 1
    Methods belong to a class and are called with dotted notation on an object of that class.
  2. 2
    Lists are mutable, so methods such as append() and sort() can modify the original list in place.
  3. 3
    In-place list methods change the list and return None rather than returning a new list.
  4. 4
    If multiple variables refer to the same list, a change through one variable is visible through all of them.
  5. 5
    Strings and tuples are immutable, so operations do not modify the original object in place.
  6. 6
    Use help(list) to inspect the methods available for list objects.

Key Takeaways

  • A method is defined for a class and is accessed through an object with dotted notation.
  • A mutable list can be changed in place, while immutable strings and tuples cannot be changed in place.
  • List methods such as append() and sort() modify the original list and return None.
  • Multiple variables can refer to the same list, so an in-place change is visible through every reference.
  • help(list) displays documentation for the list class and its available methods.

Related Topics

Related concepts

More concepts starting with T