Are Python strings mutable?

No. Operations that appear to change a string produce another string rather than altering its existing contents.

Does a tuple containing a list make that list immutable?

No. The tuple's references are fixed, but the referenced list can still change.

Is mutation always bad practice?

No. It is a normal programming capability; the important issue is whether changes and sharing are intentional and understandable.

AI Glossary / Data science and analytics / Beginner

Mutable Data Types

Definition

Mutable data types are types whose objects can have their contents or state changed after creation. In Python, common examples include lists, dictionaries, and sets. Mutation changes an existing object rather than merely assigning a variable name to a different object. This distinction matters because several parts of a program may refer to the same object and therefore observe the same change.

What it means

A variable name is not the object itself. If two names refer to one list, modifying the list through either name changes what both names observe. By contrast, assigning one name to a new list does not redirect the other name. Mutable objects are useful for accumulating and updating data, but shared references can create unexpected effects when a programmer assumes assignment automatically creates an independent copy.

How it works

An operation such as appending to a list, updating a dictionary entry, or adding an element to a set mutates that container. Whether a particular operation changes an object or produces another one depends on its type and implementation. A shallow copy creates a new outer container while retaining references to contained objects. A deep copy recursively copies supported contained objects, subject to the copying rules. Mutability is therefore relevant at every level of a nested structure, not just at its outermost layer.

Three practical examples

Data preparation: a list collects validated records as a program processes input, allowing new records to be appended.
Application state: a dictionary stores current settings or counts and updates values as events occur.
Analysis workflows: a team creates deliberate copies before modifying nested data so an exploratory transformation does not unexpectedly alter a shared working dataset.

Think of it this way

Think of two people holding keys to the same editable notebook. Either can change the notebook, and both then see the edited pages. Giving one person a different notebook changes that person's reference without changing the first notebook. The analogy becomes more complicated when copied notebooks still point to shared supplementary pages, as shallow copies can do.

Worked example

In Python, begin with original = [[1, 2], [3, 4]] and alias = original. Both names refer to the same outer list. Now set shallow = original.copy(). The outer list named shallow is new, but its two inner lists are shared with original. If shallow[0].append(9) is executed, original and alias both show [[1, 2, 9], [3, 4]], because the first inner list was mutated.
Next execute shallow.append([5, 6]). This changes only shallow's outer list, so original still has two inner lists while shallow has three. Finally, assigning alias = [] rebinds alias to a new empty list; it does not empty original. To remove the contents of the shared original outer list in place, an operation such as original.clear() would have a different effect. This sequence distinguishes object mutation, shallow copying, and name rebinding. An appropriate deep copy made before the changes could separate the nested lists as well.

Illustrative case study

In a fictional analysis team, a helper function receives a list of category names and appends an extra category. A later chart unexpectedly includes that category because it uses the same list. The team decides whether the helper should intentionally update shared state or return a separate result, and documents the chosen behavior. This case illustrates an interface decision: mutation is useful when deliberate, but surprising when callers expect their input to remain unchanged.

Common misconceptions and mistakes

Assignment does not automatically copy an object. A shallow copy does not make every nested object independent. An immutable outer container can still contain references to mutable objects; for example, a tuple can contain a list whose contents change. Mutability and hashability are related but distinct concepts, and custom types require attention to their definitions. A method that mutates an object may return None rather than the updated object, so assigning its return value can accidentally replace a useful reference.

Business use

Use mutable structures when ongoing updates make the workflow clear and efficient. Define which component owns shared data and whether functions may alter inputs. Copy deliberately at boundaries where independent state is required, considering both correctness and memory cost. Avoid assuming every library's copy operation has identical depth or behavior. For repeated analyses, protect the original data or make transformations explicit so results are reproducible and one exploratory change does not silently influence later work.

Check your understanding

Why does appending 9 to shallow[0] affect original, while appending a new inner list to shallow does not?

Answer: The shallow copy has its own outer list but shares the existing inner lists. The first operation changes a shared inner object; the second changes only the new outer container.

Related terms

Aliasing (factorial experiments)
Shallow Copy
Deep Copy
Mutable object
immutable object
object identity
aliasing
reference
side effect
variable rebinding

Learn next

Trace references in a small nested-list example before and after assignment, mutation, and copying. Then inspect a function that accepts a mutable argument and state clearly whether callers should expect that argument to change. Compare shallow and deep copying only after identifying which nested objects require independence.

Sources

Python, objects, identity, and mutability: https://docs.python.org/3/reference/datamodel.html#objects-values-and-types Python, mutable sequence operations: https://docs.python.org/3/library/stdtypes.html Python, shallow and deep copy operations: https://docs.python.org/3/library/copy.html

Previous: Music alignment Next: Mutation