3.1.1. Quick example

>>> l = [1, 2, 3]
>>> l[0]
1
>>> l.append(1)
>>> l
[1, 2, 3, 1]

3.1.2. Difference between append() and extend()

Lists have several methods amongst which the append() and extend() methods. The former appends an object to the end of the list (e.g., another list) while the later appends each element of the iterable object (e.g., anothee list) to the end of the list.

For example, we can append an object (here the character ‘c’) to the end of a simple list as follows:

>>> stack = ['a','b']
>>> stack.append('c')
>>> stack
['a', 'b', 'c']

However, if we want to append several objects contained in a list, the result as expected (or not…) is:

>>> stack.append(['d', 'e', 'f'])
>>> stack
['a', 'b', 'c', ['d', 'e', 'f']]

The object ['d', 'e', 'f'] has been appended to the exiistng list. However, it happens that sometimes what we want is to append the elements one by one of a given list rather the list itself. You can do that manually of course, but a better solution is to use the extend() method as follows:

>>> stack = ['a', 'b', 'c']
>>> stack.extend(['d', 'e','f'])
>>> stack
['a', 'b', 'c', 'd', 'e', 'f']

3.1.3. Other list methods

>>> my_list = ['a','b','c','b', 'a']
>>> my_list.index('b')
1

>>> my_list = ['a','b','c','b', 'a']
>>> my_list.index('b', 2)
3

>>> my_list.insert(2, 'a')
>>> my_list
['b', 'c', 'a', 'b']

>>> my_list.remove('a')
>>> my_list
['b', 'c', 'b', 'a']

>>> my_list.pop()
'a'
>>> my_list
['b', 'c', 'b']

>>> my_list.count('b')
2

>>> my_list.sort()
>>> my_list
['a', 'b', 'b', 'c']

>>> my_list.sort(reverse=True)
>>> my_list
['c', 'b', 'b', 'a']

>>> my_list = ['a', 'c' ,'b']
>>> my_list.reverse()
>>> my_list
['b', 'c', 'a']

3.1.4. Operators

The + operator can be used to extend a list:

>>> my_list = [1]
>>> my_list += [2]
>>> my_list
[1, 2]
>>> my_list += [3, 4]
>>> my_list
[1, 2, 3, 4]

The * operator ease the creation of list with similar values

>>> my_list = [1, 2]
>>> my_list = my_list * 2
>>> my_list
[1, 2, 1, 2]

3.1.5. Slicing

Slicing uses the symbol : to access to part of a list:

>>> list[first index:last index:step]
>>> list[:]

>>> a = [0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5]
>>> a[2:]
[2, 3, 4, 5]
>>> a[:2]
[0, 1]
>>> a[2:-1]
[2, 3, 4]

By default the first index is 0, the last index is the last one…, and the step is 1. The step is optional. So the following slicing are equivalent:

>>> a = [1, 2, 3, 4, 5, 6, 7, 8]
>>> a[:]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> a[::1]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> a[0::1]
[1, 2, 3, 4, 5, 6, 7, 8]

3.1.6. List comprehension

Traditionally, a piece of code that loops over a sequence could be written as follows:

>>> evens = []
>>> for i in range(10):
...     if i % 2 == 0:
...         evens.append(i)
>>> evens
[0, 2, 4, 6, 8]

This may work, but it actually makes things slower for Python because the interpreter works on each loop to determine what part of the sequence has to be changed.

A list comprehension is the correct answer:

>>> [i for i in range(10) if i % 2 == 0]
[0, 2, 4, 6, 8]

Besides the fact that it is more efficient, it is also shorter and involves fewer elements.

E.g. list all the length of the words except “the”  in the sentence:

sentence = "the quick brown fox jumps over the lazy dog"
words = sentence.split()
word_lengths = [len(word) for word in words if word != "the"]

3.1.7. Filtering Lists

>>> li = [1, 2]
>>> [elem*2 for elem in li if elem>1]
[4]

3.1.8. Lists as Stacks

The Python documentation gives an example of how to use lists as stacks, that is a last-in, first-out data structures (LIFO).

An item can be added to a list by using the append() method. The last item can be removed from the list by using the pop() method without passing any index to it.

>>> stack = ['a','b','c','d']
>>> stack.append('e')
>>> stack.append('f')
>>> stack
['a', 'b', 'c', 'd', 'e', 'f']
>>> stack.pop()
'f'
>>> stack
['a, 'b', 'c', 'd', 'e']

3.1.9. Lists as Queues

Another usage of list, again presented in Python documentation is to use lists as queues, that is a first in – first out (FIFO).

>>> queue = ['a', 'b', 'c', 'd']
>>> queue.append('e')
>>> queue.append('f')
>>> queue
['a', 'b', 'c', 'd', 'e', 'f']
>>> queue.pop(0)
'a'

3.1.10. How to copy a list

There are three ways to copy a list:

>>> l2 = list(l)
>>> l2 = l[:]
>>> import copy
>>> l2 = copy.copy(l)

The preceding techniques for copying a list create shallow copies. IT means that nested objects will not be copied. Consider this example:

>>> a = [1, 2, [3, 4]]
>>> b = a[:]
>>> a[2][0] = 10
>>> a
[1, 2, [10, 4]]
>>> b
[1, 2, [10, 4]]

To get around this problem, you must perform a deep copy:

>>> import copy
>>> a = [1, 2, [3, 4]]
>>> b = copy.deepcopy(a)
>>> a[2][0] = 10
>>> a
[1, 2, [10, 4]]
>>> b
[1, 2, [3, 4]]

>>> x = [4, 1]
>>> x.sort()
>>> import bisect
>>> bisect.insort(x, 2)
>>> x
[1, 2, 4]

>>> x = [4, 1]
>>> x.sort()
>>> import bisect
>>> bisect.bisect(x, 2)
2