Lists and tuples

Lists

k = [1, 3, 5]       # a list is a sequence of values
m = [7]             # a list with just one element
n = []              # an empty list (no elements)
p = ['a', 3, 2.9]   # list can contain mixed types

x = [1, 2] + [7, 8]     # -> [1, 2, 7, 8] lists can be added
y = [0]*5               # -> [0, 0, 0, 0, 0] or multiplied
z = [5, 3]*3            # -> [5, 3, 5, 3, 5, 3]

Tuples

#
# A tuple is like a list but it is immutable
# (the contents of a tuple cannot be changed after creating it)
#

t = (1, 3, 5)       # a tuple is a sequence of values
m = (7,)            # a tuple with just one element - comma required
v = (7)             # -> 7 (without the comma, it is just
                    #       a number in brackets)
n = ()              # an empty tuple (no elements)
p = ('a', 3, 2.9)   # tuple can contain mixed types

x = (1, 2) + (7, 8)     # -> (1, 2, 7, 8) tuples can be added
y = (0)*5               # -> (0, 0, 0, 0, 0) or multiplied
z = (5, 3)*3            # -> (5, 3, 5, 3, 5, 3)

Reading elements

#
# Reading elements works similarly for lists or tuples
# First lists:
#

k = [1, 3, 5]
k[0]                # -> 1 (the first element,
                    #       elements are numbered from 0)
k[2]                # -> 5 (the third element)
k[3]                # ERROR, there is no fourth element

k[-1]               # 5 (the last element, short for len-1)
k[-2]               # 3 (the second to last element, short for len-2)

#
# Tuples are the same:
#

t = (1, 3, 5)
t[0]                # -> 1 (the first element,
                    #       elements are numbered from 0)
t[2]                # -> 5 (the third element)
t[3]                # ERROR, there is no fourth element

t[-1]               # 5 (the last element, short for len-1)
t[-2]               # 3 (the second to last element, short for len-2)

#
# Reading slices (also works for tuples in the same way)
#

m = [2, 4, 6, 8]
m[1:3]              # [4, 6] (reads from element 1 up to
                    #         but not including element 3)
m[2:]               # [6, 8] (reads from element 2 to the end)
m[:3]               # [2, 4, 6] (reads from start up to
                    #            but not including element 3)
m[:]                # [2, 4, 6, 8] (reads from start to end)

y = x[:]            # creates a shallow copy of x and assigns to y
                    # if x is a list it creates a list
                    # if x is a tuple it creates a tuple

lst = [1, 2, 3, 4, 5, 6, 7, 8]
lst[1:6:2]          # [2, 4, 6] (reads from element 1 up to but not
                    #            including element 6, in steps of 2)
lst[5:2:-1]         # [6, 5, 4] (reads from element 5 down to but not
                    #            including element 2, in steps of -1)
lst[::-1]           # Counts from the end of the list to the start of
                    # the list is steps of -1, ie it creates a
                    # reversed copy [8, 7, 6, 5, 4, 3, 2, 1]

Functions that work with lists and tuples

#
# Functions that return information about a sequence will
# work with lists or tuples
#

k = [1, 3, 2, 1, 2, 5]

len(k)              # -> 6 the length of the list/tuple
k.count(1)          # -> 2 (the value 1 appears 2 times in k)
k.count(8)          # -> 0 (the value 8 isn't in k)
1 in k              # -> True (1 appears in k at least once)
8 in k              # -> False (8 does not appear in k)
k.index(3)          # -> 1 (value 3 first appears at position 1)
k.index(2, 3)       # -> 4 (searches for the first value 2 in the
                    #       list from position 3 onwards)
k.index(1, 2, 4)    # -> 3 (searches for the first value 1 in the
                    #       list between positions 2 and 4)
k.index(7)          # ValueError (because 7 is not present)
k.copy()            # creates a shallow copy of the list or tuple

Tuple packing and unpacking

#
# These only work with tuples (except unpacking works with lists too)
#

t = 1, 2            # creates a tuple (1, 2)
u = 5,              # creates a tuple (5,)
v = ()              # there is no packing syntax for empty tuples

a, b = t            # unpacks t into a and b: sets a = 1, b = 2
                    # the number of variables must match the number of
                    # values in the tuple
                    # this also works with lists
w = (5, 6, 7, 8)
a, *b, c = w        # set a = 5, b = [6, 7], c = 8
                    # *b takes all spare values as a list

x, y = 1, 2         # multiple assignment, sets x = 1, y = 2
                    # actually 1, 2 is packed into a tuple
                    # then unpacked

x, y = y, x         # swap values of x and y
                    # actually x, y is packed into a tuple
                    # then unpacked in swapped order

List only functions

#
# These functions modify the list, so cannot be used with tuples
#

k = [1, 3, 5, 7, 9]
k[1] = 4            # k -> [1, 4, 5, 7, 9]
                    # sets value of element 1
k[1:4] = [0, 0, 0]  # k -> [1, 0, 0, 0, 9]
                    # replace a slice with new values

k.append(9)         # k -> [1, 7, 5, 9] (adds value to end of list)

k.extend([10, 11, 12])  # k -> [1, 7, 5, 9, 10, 11, 12]
                        # joins sequence to end of list

m = [0, 0, 0]
m.insert(1, 5)      # m -> [0, 5, 0, 0]
                    # insert 5 at index 1
m.insert(0, 6)      # m -> [6, 0, 5, 0, 0]
                    # insert 6 at start (index 0)
m.insert(len(m), 7) # m -> [6, 0, 5, 0, 0, 7]
                    # insert 7 at end (index len(m))

n = [2, 4, 6, 4, 8, 10]
n.remove(4)         # n -> [2, 6, 4, 8, 10]
                    # remove first element with value 4
                    # error id not found
n.pop()             # -> 10
                    # n -> [2, 6, 4, 8]
                    # removes last element and returns its value
n.pop(2)            # -> 4
                    # n -> [2, 6, 8]
                    # removes element at index and returns its value
n.clear()           # n -> [] (clear all elements)

p = [10, 11, 12, 13, 14]
del p[1]            # p -> [10, 12, 13, 14]
                    # remove element 1
                    # similar to pop but doesn't return a value
del p[1:4]          # p -> [10, 14]
                    # remove a slice
del p[:]            # p -> []
                    # remove all elments, equivalent to clear