Concepts / String Methods and Immutability

String Methods and Immutability

Most list methods modify the list in place and return None, unlike string methods which return a new string. This is because lists are mutable and strings are immutable.

  • Programming

One Method, Two Outcomes

A method call can change a value in place or return a new value. This difference is especially important when comparing lists and strings. Most list methods modify the existing list and return None. String methods, in contrast, return a new string. Confusing these behaviors can turn a valid-looking assignment into a variable that no longer refers to the list you intended to keep.

ListmutableList methodchanges existing listNonemethod returnStringimmutableString methodreturns new stringNew stringmethod returncall methodreturnscall methodreturns
How does mutability affect whether a method changes an existing value or returns a new one?

Tracing a List Method

Consider a list named scores containing several values. Calling scores.sort() changes the list itself. The important result is not a replacement list returned by sort(); the method returns None. Therefore, the list can be changed successfully even though the method call does not produce a list value for an assignment.

scores[3, 1, 2]sort()method callscores[1, 2, 3]Nonemethod returncallchanges existing listreturns
What changes when sort() modifies the existing list?
Worked example

Sorting Without Reassignment

A variable named scores refers to a list. You want the list sorted.

  1. 1
    Start

    scores refers to a list whose elements are not yet in sorted order.

  2. 2
    Call the method

    Use scores.sort() without assigning its result back to scores.

  3. 3
    Observe the two results

    The existing list is modified, while the return value of sort() is None.

Result

The list is sorted, and scores still refers to the modified list.

Tracing a String Method

Strings follow the opposite pattern described in this topic. A string is immutable, so its existing contents are not changed by a string method. Instead, the method returns a new string. To keep that new string, assignment is appropriate: a variable can be made to refer to the returned string.

textoriginal stringString methoddoes not change originalNew stringreturned valuecallreturns
What happens when a string method is used on immutable text?
Value typeMutabilityTypical method behaviorReturn value described in this topic
ListMutableModifies the list in placeNone for most list methods
StringImmutableReturns a new stringThe new string

The central contrast between list methods and string methods

The Reassignment Trap

What do you think happens?

Suppose scores is a list. What happens after assigning scores.sort() back to scores?

  • scores becomes the sorted list

  • scores remains the original unsorted list

  • scores becomes None

Reveal answer
Answer:

scores becomes None

sort() modifies the existing list but returns None. Assigning that return value back to scores replaces the list reference with None.

scoresa listsort()modifies listNonereturned valuescoresNonecall methodreturnsassigned to
What value flows into the variable when a list method's return value is assigned back to it?
Before
scores.sort()

The list is modified in place and scores continues to refer to the list.

After
scores = scores.sort()

The list is modified, then scores is assigned the method's return value, None.

Adding and Removing Carefully

Python provides multiple ways to add and remove elements from lists. The key point for this article is to separate the operation from the method's return value. For an adding operation using append(), write the method call by itself when you want to modify the list. Do not turn that call into an assignment to the same list variable. The same caution applies when using list methods for removal: check whether the method changes the list in place and what it returns before assigning anything.

itemsexisting listList methodadd or removeitemsmodified listNonedo not assign backcallchanges listreturns
Where does the list operation leave the variable when the method call is used without reassignment?
Worked example

An Addition Operation

You want to add one element to a list using append().

  1. 1
    Correct form

    Call items.append(element) without assigning the result back to items.

  2. 2
    Why it works

    The list is modified in place. The method's return value is not used to replace the list variable.

  3. 3
    Incorrect form

    Writing items = items.append(element) assigns None to items because append() returns None.

Result

Use the list method as an operation on the list, not as a replacement value for the list variable.

Legal Syntax, Wrong Result

A common debugging trap is assuming that incorrect code must produce an error. Assigning the result of a list method back to the list variable is syntactically legal. Python can perform the method call, modify the list, return None, and then complete the assignment. The result is wrong because the variable has been overwritten, not because the syntax was rejected.

  • Common mistake

    Assigning sort() back to the list variable.

    What it looks like
    scores = scores.sort()
    Why it fails

    sort() modifies the list in place and returns None, so the assignment replaces scores with None.

    Do this instead

    Call scores.sort() without assigning its return value.

  • Common mistake

    Assigning append() back to the list variable.

    What it looks like
    items = items.append(element)
    Why it fails

    append() is a list method named in the source as an example of a method whose result should not be assigned back to the list.

    Do this instead

    Call items.append(element) without assigning the result to items.

  • Common mistake

    Assuming every method behaves like a string method.

    What it looks like

    Treating a list method as though it returns a replacement list.

    Why it fails

    Most list methods modify the list in place and return None, while string methods return a new string.

    Do this instead

    Check whether the value is a mutable list or an immutable string before deciding whether to assign the method result.

Verify Before You Rely

Interactive testing is a practical way to confirm a method's behavior before using it in real code. Test the operation, inspect the list after the call, and inspect the method's return value separately. This helps you distinguish a method that changes an existing list from one that returns a new string, and it can reveal accidental reassignment before it reaches a larger program.

  1. 1
    Start with a small list or string value.
  2. 2
    Call the method without assigning its result when testing an in-place list operation.
  3. 3
    Inspect the value after the call to see whether the existing list changed.
  4. 4
    If you need to understand the return value, evaluate the method call separately.
  5. 5
    Only assign a method result after verifying that the method returns the kind of value you intend to keep.
EASY

A variable named records refers to a list. You want to use a list method to change it, but you are unsure whether the method returns a useful replacement value. Describe the two separate checks you should make before assigning the method result back to records.

Hints
  • Ask whether the method changes the existing list in place.
  • Check what value the method returns.
  • Remember that most list methods return None.

Key Takeaways

  1. 1
    Lists are mutable, so most list methods modify the existing list in place and return None.
  2. 2
    Strings are immutable, so string methods return a new string rather than changing the existing string.
  3. 3
    Do not assign the result of list methods such as sort() or append() back to the list variable.
  4. 4
    Code can be syntactically legal and still produce the wrong result by replacing a list variable with None.
  5. 5
    Test unfamiliar list methods interactively before using them in real code.

At a glance

  • Most list methods modify lists in place and return None.
  • String methods return new strings because strings are immutable.
  • Assigning a list method's return value back to the list variable can replace the list with None.
  • Correct-looking syntax can still produce an incorrect result, so test method behavior interactively.

Related Topics

Related concepts

More concepts starting with S