# Python Programming/Tuples

A tuple in Python is much like a list except that it is immutable
(unchangeable) once created. A tuple of hashable objects is hashable and
thus suitable as a key in a dictionary and
as a member of a set.

## Overview

Tuples in Python at a glance:

``` python
tup1  = (1, 'a')
tup2  = 1, 'a'                # Brackets not needed
tup3  = (1,)                  # Singleton
tup4  = 1,                    # Singleton without brackets
tup5 = ()                     # Empty tuple
list1 = [1, 'a']
it1, it2 = tup1               # Assign items
print(tup1 == tup2)           # True
print(tup1 == list1)          # False
print(tup1 == tuple(list1))   # True
print(list(tup1) == list1)    # True
print(tup1[0])                # First member
for item in tup1: print(item) # Iteration
print((1, 2) + (3, 4))        # (1, 2, 3, 4)
tup1 += (3,)
print(tup1)                   # (1, 'a', 3), despite immutability
print(len(tup1))              # Length AKA size AKA item count
print(3 in tup1)              # Membership - true
return r1, r2                 # Return multiple values
r1, r2 = myfun()              # Receive multiple values
tup6 = ([1,2],)
tup6[0][0]=3
print(tup6)                   # The list within is mutable
set1 = set( (1,2) )           # Can be placed into a set
#set1 = set( ([1,2], 2) )     # Error: The list within makes it unhashable
```

## Tuple notation

Tuples may be created directly or converted from lists. Generally,
tuples are enclosed in parentheses.

``` python
>>> l = [1, 'a', [6, 3.14]]
>>> t = (1, 'a', [6, 3.14])
>>> t
(1, 'a', [6, 3.14])
>>> tuple(l)
(1, 'a', [6, 3.14])
>>> t == tuple(l)
True
>>> t == l
False
```

A one item tuple is created by an item in parentheses followed by a
comma:

``` python
>>> t = ('A single item tuple',)
>>> t
('A single item tuple',)
```

Also, tuples will be created from items separated by commas.

``` python
>>> t = 'A', 'tuple', 'needs', 'no', 'parens'
>>> t
('A', 'tuple', 'needs', 'no', 'parens')
```

## Packing and Unpacking

You can also perform multiple assignment using tuples.

``` python
>>> article, noun, verb, adjective, direct_object = t   #t is defined above
>>> noun
'tuple'
```

Note that either, or both sides of an assignment operator can consist of
tuples.

``` python
>>> a, b = 1, 2
>>> b
2
```

The example above: article, noun, verb, adjective, direct_object = t is
called \"tuple unpacking\" because the tuple *t* was unpacked and its
values assigned to each of the variables on the left. \"Tuple packing\"
is the reverse: t=article, noun, verb, adjective, direct_object. When
unpacking a tuple, or performing multiple assignment, you must have the
same number of variables being assigned to as values being assigned.

## Operations on tuples

These are the same as for lists except that we may not assign to indices
or slices, and there is no \"append\" operator.

``` python
>>> a = (1, 2)
>>> b = (3, 4)
>>> a + b
(1, 2, 3, 4)
>>> a
(1, 2)
>>> b
(3, 4)
>>> a.append(3)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'append'
>>> a
(1, 2)
>>> a[0] = 0
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
>>> a
(1, 2)
```

For lists we would have had:

``` python
>>> a = [1, 2]
>>> b = [3, 4]
>>> a + b
[1, 2, 3, 4]
>>> a
[1, 2]
>>> b
[3, 4]
>>> a.append(3)
>>> a
[1, 2, 3]
>>> a[0] = 0
>>> a
[0, 2, 3]
```

### Tuple Attributes

Length: Finding the length of a tuple is the same as with lists; use the
built in len() method.

``` python
>>> len( ( 1, 2, 3) )
3
>>> a = ( 1, 2, 3, 4 )
>>> len( a )
4
```

### Conversions

Convert list to tuples using the built in tuple() method.

``` python
>>> l = [4, 5, 6]
>>> tuple(l)
(4, 5, 6)
```

Converting a tuple into a list using the built in list() method to cast
as a list:

``` python
>>> t = (4, 5, 6)
>>> list(t)
[4, 5, 6]
```

Dictionaries can also be converted to tuples of tuples using the items
method of dictionaries:

``` python
>>> d = {'a': 1, 'b': 2}
>>> tuple(d.items())
(('a', 1), ('b', 2))
```

## Uses of Tuples

Tuples can be used in place of lists where the number of items is known
and small, for example when returning multiple values from a function.
Many other languages require creating an object or container to return,
but with Python\'s tuple assignment, multiple-value returns are easy:

``` python
def func(x, y):
    # code to compute x and y
    return x, y
```

This resulting tuple can be easily unpacked with the tuple assignment
technique explained above:

``` python
x, y = func(1, 2)
```

## Using List Comprehension to process Tuple elements

Occasionally, there is a need to manipulate the values contained within
a tuple in order to create a new tuple. For example, if we wanted a way
to double all of the values within a tuple, we can combine some of the
above information in addition to list
comprehension
like this:

``` python
def double(T):
    'double() - return a tuple with each tuple element (e) doubled.'
    return tuple( [ e * 2 for e in T ] )
```

## Exercises

1.  Create the list \[\'a\', \'b\', \'c\'\], then create a tuple from
    that list.
2.  Create the tuple (\'a\', \'b\', \'c\'), then create a list from that
    tuple. (Hint: the material needed to do this has been covered, but
    it\'s not entirely obvious)
3.  Make the following instantiations simultaneously: a = \'a\', b=2,
    c=\'gamma\'. (That is, in one line of code).
4.  Create a tuple containing just a single element which in turn
    contains the three elements \'a\', \'b\', and \'c\'. Verify that the
    length is actually 1 by using the len() function.

## External links

-   Python documentation, chapter \"Sequence
    Types\"
    \-- python.org
-   Python documentation, chapter \"Tuples and
    Sequences\"
    \-- python.org

