# Tuples Are Immutable

A tuple is a sequence of values. The values can be any type, and they are indexed by integers, so in that respect tuples are a lot like lists. The important difference is that tuples are immutable.

Syntactically, a tuple is a comma-separated list of values:

`>>> t = 'a', 'b', 'c', 'd', 'e'`

Although it is not necessary, it is common to enclose tuples in parentheses:

`>>> t = ('a', 'b', 'c', 'd', 'e')`

To create a tuple with a single element, you have to include a final comma:

```>>> t1 = 'a',
>>> type(t1)
<type 'tuple'>```

A value in parentheses is not a tuple:

```>>> t2 = ('a')
>>> type(t2)
<type 'str'>```

Another way to create a tuple is the built-in function `tuple`. With no argument, it creates an empty tuple:

```>>> t = tuple()
>>> print t
()```

If the argument is a sequence (string, list or tuple), the result is a tuple with the elements of the sequence:

```>>> t = tuple('lupins')
>>> print t
('l', 'u', 'p', 'i', 'n', 's')```

Because `tuple` is the name of a built-in function, you should avoid using it as a variable name.

Most list operators also work on tuples. The bracket operator indexes an element:

```>>> t = ('a', 'b', 'c', 'd', 'e')
>>> print t[0]
'a'```

And the slice operator selects a range of elements.

```>>> print t[1:3]
('b', 'c')```

But if you try to modify one of the elements of the tuple, you get an error:

```>>> t[0] = 'A'
TypeError: object doesn't support item assignment```

You can’t modify the elements of a tuple, but you can replace one tuple with another:

`>>> t = ('A',) + t[1:] >>> print ...`

Get Think Python now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.