Python’s lists and tuples both store ordered sequences of items. The main difference is mutability: lists can be changed after creation; tuples cannot. That difference drives when to use each type—for example, lists for collections you build or modify, tuples for fixed data or dictionary keys. This article explains the distinction and gives practical guidelines.

One-sentence difference

Lists are mutable (you can add, remove, or change elements after creation). Tuples are immutable (you cannot change their contents). Both are ordered and can hold any mix of types. See Mutable vs immutable for the broader idea.

Syntax

Lists use square brackets; tuples use parentheses (or no brackets when the context is clear):

my_list = [1, 2, 3]      # list
my_tuple = (1, 2, 3)     # tuple

# Single-element tuple needs a comma:
one = (1,)               # tuple
not_tuple = (1)          # just the int 1

Mutability in practice

You can append, remove, or reassign list elements. Tuples have no append, remove, or item assignment:

lst = [1, 2, 3]
lst.append(4)    # OK
lst[0] = 99     # OK

tup = (1, 2, 3)
# tup.append(4)  # AttributeError: tuple has no append
# tup[0] = 99   # TypeError: 'tuple' does not support item assignment

You can still read by index (tup[0]) and slice tuples; you just cannot change them. For more on why immutability matters, see Mutable vs immutable and Shallow vs deep copy.

When to use a list

  • You need to add, remove, or change items (e.g. building a list in a loop, or updating it over time).
  • The collection is “a bunch of things” that may grow or shrink.
  • You want list-only methods like .append(), .extend(), .sort() in place. See List methods.

When to use a tuple

  • The data should not change (e.g. coordinates (x, y), or a fixed record like (name, age, city)).
  • You need a dictionary key—keys must be hashable and immutable, so lists cannot be keys; tuples can. See Dictionaries.
  • You are returning multiple values from a function: return name, age returns a tuple. Unpacking works the same: a, b = f().

Simple rule of thumb

If you will modify the sequence (add, remove, or change elements) → use a list. If the sequence is fixed or must be hashable → use a tuple.

Next steps: Core Concepts · Mutable vs immutable · List methods · Lists