Lists and Tuples

================

Lists

-----

Python provides an intuitive way to represent a group items, called *Lists*. The

items of a *List* are called its elements. Unlike C/C++, elements can be of any

type. A *List* is represented as a list of comma-sepated elements with square

brackets around them::

  >>> a = [10, 'Python programming', 20.3523, 23, 3534534L]

  >>> a

  [10, 'Python programming', 20.3523, 23, 3534534L]

Common List Operations

~~~~~~~~~~~~~~~~~~~~~~

The following are some of the most commonly used operations on *Lists*.

~~~~~~~~

Indexing

~~~~~~~~

Individual elements of a *List* can be accessed using an index to the element.

The indices start at 0. One can also access the elements of the *List* in reverse

using negative indices.::

  >>> a[1]

  'Python programming'

  >>> a[-1]

  3534534L

It is important to note here that the last element of the *List* has an index of

-1.

~~~~~~~~~~~~~

Concatenating

~~~~~~~~~~~~~

Two or more *Lists* can be concatenated using the + operator::

  >>> a + ['foo', 12, 23.3432, 54]

  [10, 'Python programming', 20.3523, 'foo', 12, 23.3432, 54]

  >>> [54, 75, 23] + ['write', 67, 'read']

  [54, 75, 23, 'write', 67, 'read']

~~~~~~~

Slicing

~~~~~~~

A *List* can be sliced off to contain a subset of elements of the *List*. Slicing

can be done by using two indices separated by a colon, where the first index is

inclusive and the second index is exclusive. The resulting slice is also a *List*.::

  >>> num = [1, 2, 3, 4, 5, 6, 7, 8, 9]

  >>> num[3:6]

  [4, 5, 6]

  >>> num[0:1]

  [1]

  >>> num[7:10]

  [7, 8, 9]

The last example showed how to access last 3 elements of the *List*. There is a 

small catch here. The second index 10 actually refers to the 11th element of the

*List* which is still valid, even though it doesn't exist because the second 

index is exclusive and tells the Python interpreter to get the last element of

the *List*. But this can also be done in a much easier way using negative indices::

  >>> num[-3:-1]

  [7, 8, 9]

Excluding the first index implies that the slice must start at the beginning of 

the *List*, while excluding the second index includes all the elements till the

end of the *List*. A third parameter to a slice, which is implicitly taken as 1

is the step of the slice. It is specified as a value which follows a colon after

the second index::

  >>> num[:4]

  [1, 2, 3, 4]

  >>> num[7:]

  [8, 9]

  >>> num[-3:]

  [7, 8, 9]

  >>> num[:]

  [1, 2, 3, 4, 5, 6, 7, 8, 9]

  >>> num[4:9:3]

  [5, 8]

  >>> num[3::2]

  [4, 6, 8]

  >>> num[::4]

  [1, 5, 9]

~~~~~~~~~~~~~~

Multiplication

~~~~~~~~~~~~~~

A *List* can be multiplied with an integer to repeat itself::

  >>> [20] * 5

  [20, 20, 20, 20, 20]

  >>> [42, 'Python', 54] * 3

  [42, 'Python', 54, 42, 'Python', 54, 42, 'Python', 54]

~~~~~~~~~~

Membership

~~~~~~~~~~

**in** operator is used to find whether an element is part of the *List*. It

returns **True** if the element is present in the *List* or **False** if it is not 

present. Since this operator returns a Boolean value it is called a Boolean

operator::

  >>> names = ['Guido', 'Alex', 'Tim']

  >>> 'Tim' in names

  True

  >>> 'Adam' in names

  False

~~~~~~~~~~~~~~~~~~~~~~~~~~~

Length, Maximum and Minimum

~~~~~~~~~~~~~~~~~~~~~~~~~~~

Length of a *List* can be found out using the len function. The max function

returns the element with the largest value and the min function returns the 

element with the smallest value::

  >>> num = [4, 1, 32, 12, 67, 34, 65]

  >>> len(num)

  7

  >>> max(num)

  67

  >>> min(num)

  1

~~~~~~~~~~~~~~~~~

Changing Elements

~~~~~~~~~~~~~~~~~

Unlike Strings *Lists* are mutable, i.e. elements of a *List* can be manipulated::

  >>> a = [1, 3, 5, 7]

  >>> a[2] = 9

  >>> a

  [1, 3, 9, 7]

~~~~~~~~~~~~~~~~~

Deleting Elements

~~~~~~~~~~~~~~~~~

An element or a slice of a *List* can be deleted by using the **del** statement::

  >>> a = [1, 3, 5, 7, 9, 11]

  >>> del a[-2:]

  >>> a

  [1, 3, 5, 7]

  >>> del a[1]

  >>> a

  [1, 5, 7]

~~~~~~~~~~~~~~~~

Assign to Slices

~~~~~~~~~~~~~~~~

In the same way, values can be assigned to individual elements of the *List*, 

a *List* of elements can be assigned to a slice::

  >>> a = [2, 3, 4, 5]

  >>> a[:2] = [0, 1]

  [0, 1, 4, 5]

  >>> a[2:2] = [2, 3]

  >>> a

  [0, 1, 2, 3, 4, 5]

  >>> a[2:4] = []

  >>> a

  [0, 1, 4, 5]

The last two examples should be particularly noted carefully. The last but one

example insert elements or a list of elements into a *List* and the last example

deletes a list of elements from the *List*.

None, Empty Lists, and Initialization

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

An *Empty List* is a *List* with no elements and is simply represented as

[]. A *None List* is one with all elements in it being **None**. It serves

the purpose having a container list of some fixed number of elements with

no value::

  >>> a = []

  >>> a

  []

  >>> n = [None] * 10

  >>> n

  [None, None, None, None, None, None, None, None, None, None]

Nested Lists

~~~~~~~~~~~~

As mentioned earlier, a List can contain elements of any data type. This also

implies a *List* can have a *Lists* themselves as its elements. These are 

called as *Nested Lists*. There is no limit on the depth of the *Nested Lists*::

  >>> a = [1, [1, 2, 3], 3, [1, [1, 2, 3]], 7]

List Methods

~~~~~~~~~~~~

A method is a function that is coupled to an object. More about objects

and its methods are discussed in Advanced Python module. In general, a

method is called like::

  object.method(arguments)

For now, it is enough to know that a list of elements is an object and

so *List* methods can be called upon them. Also some of the methods change

the *List* in-place, meaning it modifies the existing list instead of creating

a new one, while other methods don't. It must be noted as we run through

the *List* methods.

Some of the most commonly used *List* methods are as follows:

~~~~~~

append

~~~~~~

The *append* method is used to append an object at the end of the list::

  >>> prime = [2, 3, 5]

  >>> prime.append(7)

  >>> prime

  [2, 3, 5, 7]

It is important to note that append changes the *List* in-place.

~~~~~

count

~~~~~

The *count* method returns the number of occurences of a particular element

in a list::

  >>> [1, 4, 4, 9, 9, 9].count(9)

  3

  >>> tlst = ['Python', 'is', 'a', 'beautiful', 'language']

  >>> tlst.count('Python')

  1

~~~~~~

extend

~~~~~~

The *extend* method extends the list on which it is called by the list supplied

as argument to it::

  >>> a = [1, 2, 3]

  >>> b = [4, 5, 6]

  >>> a.extend(b)

  [1, 2, 3, 4, 5, 6]

This is an in-place method. This method is equivalent to using the + operator, but

using the + operator returns a new list.

~~~~~

index

~~~~~

The *index* method returns the index position of the element in the list 

specified as argument::

  >>> a = [1, 2, 3, ,4, 5]

  >>> a.index(4)

  3

~~~~~~

insert

~~~~~~

The *insert* method is used to insert an element specified as the second 

argument to the list at the position specified by the first argument::

  >>> a = ['Python', 'is', 'cool']

  >>> a.insert(2, 'so')

  >>> a

  ['Python', 'is', 'so', 'cool']

The *insert* method changes the *List* in-place.

~~~

pop

~~~

The *pop* method removes an element from the list. The index position

of the element to be removed can be specified as an argument to the

*pop* method, if not it removes the last element by default::

  >>> a = [1, 2, 3, 4, 5]

  >>> a.pop()

  >>> a

  5

  >>> a.pop(2)

  >>> a

  3

The *pop* method changes the *List* in-place.

~~~~~~

remove

~~~~~~

The *remove* method removes the first occurence of an element supplied as a

parameter::

  >>> a = [1, 2, 3, 4, 2, 5, 2]

  >>> a.remove(2)

  >>> a

  [1, 3, 4, 2, 5, 2]

~~~~~~~

reverse

~~~~~~~

The *reverse* method reverses elements in the list. It is important to note

here that *reverse* method changes the list in-place and doesn't return any

thing::

  >>> a = ['guido', 'alex', 'tim']

  >>> a.reverse()

  >>> a

  ['tim', 'alex', 'guido']

~~~~

sort

~~~~

The *sort* method is used to sort the elements of the list. The *sort* method

also sorts in-place and does not return anything::

  >>> a = [5, 1, 3, 7, 4]

  >>> a.sort()

  >>> a

  [1, 3, 4, 5, 7]

In addition to the sort method on a *List* object we can also use the built-in

**sorted** function. This function takes the *List* as a parameter and returns

a sorted copy of the list. However the original list is left intact::

  >>> a = [5, 1, 3, 7, 4]

  >>> b = sorted(a)

  >>> b

  [1, 3, 4, 5, 7]

  >>> a

  [5, 1, 3, 7, 4]

Tuples

------

*Tuples* are sequences just like *Lists*, but they are immutable. In other

words *Tuples* provides a way to represent a group of items, where the group

of items cannot be changed in any way. The syntax of a *Tuple* is also very

similar to *List*. A *Tuple* is represented with the list of items, called

elements of the *Tuple* separated by comma, with the entire list being enclosed

in parenthesis. It is not compulsory to use parenthesis around a *Tuple* but

it may be necessary in some of the cases::

  >>> a = 1, 2, 3

  >>> a

  (1, 2, 3)

  >>> b = 1,

  >>> b

  (1,)

It is interesting to note the second example. Just a value followed by a comma

automatically makes that an element of a *Tuple* with only one element. It is

also important to note that, irrespective of input having a parenthesis, the

output always has a parenthesis.

The first example is also known as *Tuple packing*, because values are being

packed into a tuple. It is also possible to do *Tuple unpacking* which is more

interesting. It is better to understand that by example. Say we have a 

co-ordinate pair from which we need to separate x and y co-ordinates::

  >>> a = (1, 2)

  >>> x, y = a

  >>> x

  1

  >>> y

  2

*Tuple unpacking* also has several other use-cases of which the most interesting

one is to swap the values of two variables. Using programming languages like C

would require anywhere around 10 lines of code and an extra temporary variable

to do this (including all the #include stuff). Python does it in the most

intuitive way in just one line. Say we want to swap the co-ordinates in the

above example::

  >>> x, y = y, x

  >>> x

  2

  >>> y

  1

Common Tuple Operations

~~~~~~~~~~~~~~~~~~~~~~~

There is no need to introduce all the *Tuple* operations again, since *Tuples*

support the following operations that *List* supports in exactly the same way:

  * Indexing

  * Concatenating

  * Slicing

  * Membership

  * Multiplication

  * Length, Maximum, Minimum

The following examples illustrate the above operations::

  >>> a = (1, 2, 3, 4, 5, 6)

  >>> a[5]

  6

  >>> b = (7, 8, 9)

  >>> a + b

  (1, 2, 3, 4, 5, 6, 7, 8, 9)

  >>> a[3:5]

  (4, 5)

  >>> 5 in a

  True

  >>> c = (1,)

  >>> c * 5

  (1, 1, 1, 1, 1)

  >>> len(a)

  6

  >>> max(a)

  6

  >>> min(a)

  1

However the following *List* operations are not supported by *Tuples* because

*Tuples* cannot be changed once they are created:

  * Changing elements

  * Deleting elements

  * Assigning to slices

Similarity to *Lists* leads to the questions like, why not *Lists* only? Why do

we even want *Tuples*? Can we do the same with *Lists*? And the answer is **Yes**

we can do it, but *Tuples* are helpful at times, like we can return Tuples from

functions. They are also returned by some built-in functions and methods. And

also there are some use cases like co-ordinate among other things. So *Tuples*

are helpful.

Additional Syntax

-----------------

The following additional syntax are introduced to make it easier to operate on

*Lists*.

range()

~~~~~~~

The *range* function takes at least one argument and 2 additional optional

arguments. If two or more arguments are specified, the range function returns

a list of natural numbers starting from the first argument passed to it to the

second argument. The third argument, if specified is used as a step. Suppose

only one argument is specified, then *range* function returns a list of natural

numbers starting from 0 upto the argument specified::

  >>> range(5, 10, 2)

  [5, 7, 9]

  >>> range(2, 15)

  [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

  >>> range(12)

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

for

~~~

The **for** keyword is used as a part of the looping construct. Unlike for loops

in other languages, Python's for is used to iterate through the elements of 

sequences like *Lists*, *Tuples*, *Dictionaries*, etc. The syntax of the for loop

consists of **for**, followed by a variable to hold the individual or the current

element of the list during iteration and **in**, followed by the sequence and a

semicolon(':') The next line which is part of the **for** loop, i.e the statements

that are part of the loop should start with a new intend::

  >>> names = ['Guido', 'Alex', 'Tim']

  >>> for name in names:

  ...   print "Name =", name

  ... 

  Name = Guido

  Name = Alex

  Name = Tim

Conclusion

----------

This section on *Lists* and *Tuples* introduces almost all the necessary 

machinary required to work on *Lists* and *Tuples*. Topics like how to

use these data structures in bigger more useful programs will be introduced

in the subsequent chapters.