4.1 Lists

a = [10, 5, 15, 25]
b = ["eggs", "bacon", "cheese"]
c = [4, "hello", 7.3, False]

Lists are one type of collection. The easiest way of creating a list is surrounding some values with cornered brackets [] and separating the values of the list with commas ,. The values that make up a list are called items or elements. Lists can contain any type of value or variable. From this it follows that lists can also contain other lists! A list that contains another list is called a list of lists, or nested list (you may also think of this phenomenon as listception, if you ever watched Christopher Nolan’s Inception (2010)).

a = 2
b = [a, 2*a]
c = [b, 6]
print(c)

## [[2, 4], 6]

A special type of list is the so-called empty list. An empty list is a list with no elements. Empty lists are denoted with [].

a = []

In a sense, lists are similar to Strings. Strings are basically ordered collections of characters. For example, the word Hello is an ordered collection of five characters: H,e, l, l, and o. In contrast to Strings, however, the elements of lists can be of any type. Ordered collections such as strings and lists are also called sequences.

Lists are ordered collections of values. However, a list being ordered has nothing to do with how humans may be inclinded to order the elements of a list. For example, you may want to order a list a with three elements "A", "B", and "C" according to their alphabetic order: a = ["A", "B", "C"]. However, for lists, the value of an element is irrelevant for its position in the list. Lists are not ordered because they grasp some underlying semantics about their elements according to which they come up with an order. In fact, element values are arbitrary for a list. Instead, lists are called ordered because they allocate a certain position in memory to each element. Each list element occupies a unique position in memory. Elements of a list are accessed by querying the list at specified positions, so-called indices. Accessing a list at a specified index, the value located at that position in memory is returned. The index operator [] is used to access list elements at specified indices, like so

a = [1, 2, 3]
print(a[0])

## 1

print(a[1])

## 2

The expression inside the brackets of the index operator (in this case the integers 0 and 1) specifies the index of the to-be selected element. Each element inside a list has a unique index, an integer describing the element’s position in the list. One major cause of errors surrounding lists is that indices start at 0, not at 1, as you might expect. After all, to us it feels natural to start counting at 1. As you can see below, this means that the first element of a list is accessed by indexing 0.

a = ["Hello", "World", "!"]
print(a[0])

## Hello

print(a[2])

## !

Why do indices start at 0, instead of 1? As you might already expect, it has to do with how computers store information in memory. A list serves as a pointer, a reference to a memory location. The expression list[i] then refers to a memory position i-steps away from the starting element. This means that the index is used as an offset. The first element of a list is located at exactly the position the list refers to (which means that the offset is 0). Hence, the first element of a list is located at index 0.

shoppinglist = ["appels", "bananas", "tomatoes"]
shoppinglist[2] = "peaches"
print("Updated shopping list: " + ", ".join(shoppinglist))

## Updated shopping list: appels, bananas, peaches

a = [1,2]
a[0] = 10
print(a)

## [10, 2]

a = [1, "a", 2, "b", 3, "c"]
print(a[1:4])

## ['a', 2, 'b']

print(a[0:2])

## [1, 'a']

a[0:2] = "d"
print(a)

## ['d', 2, 'b', 3, 'c']

a = [1, "a", 2, "b", 3, "c"]
aCopy = a[:]
print(aCopy)

## [1, 'a', 2, 'b', 3, 'c']

a = [1,2]
a[2] = 10

## Error in py_call_impl(callable, dots$args, dots$keywords): IndexError: list assignment index out of range
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

print(a)

## [1, 2]

a = []
a.append(1)
print(a)

## [1]

a.append(2)
print(a)

## [1, 2]

a = [1,2]
b = [3,4]

a.extend(b)
print(a)

## [1, 2, 3, 4]

a = [1,2]
b = [3,4]

a.append(b)
print(a)

## [1, 2, [3, 4]]

a = [4,5]
a.append(6)
print(a)

## [4, 5, 6]

4.2 Tuples

Much like lists, tuples are ordered collections of values, but with less exentensive functionality and their unique characteristic being that they are immutable. Once you created a tuple in memory, you cannot change its elements.

thorndike = ("Edward", "Lee", "Thorndike", 1874, "Law of effect", "Law of exercise")
thorndike[4] = "Law of recency"

## Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: 'tuple' object does not support item assignment
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

Tuples are usually used when you assume that a collection of values will not change in the course of your program. They are records of related information, chunked together so that we can use them as a single entity. In the Stroop Task program for instance, we saw that tuples were used to chunk together RGB combinations that make up a color. The Pygame module used these tuples to generate color in the Stroop Task.

Tuples are immutable. However, if you really need to change the contents of an already existing tuple, you can always assign a new value to the variable which holds the tuple as a value.

thorndike = ("Edward", "Lee", "Thorndike", 1874, "Law of effect", "Law of exercise")
thorndike = thorndike[:] + ("Law of recency",)
print(thorndike)

## ('Edward', 'Lee', 'Thorndike', 1874, 'Law of effect', 'Law of exercise', 'Law of recency')

Note the trailing comma in the second line ("Law of recency",). Without the comma at the end of the parentheses, Python treats the content of a one-element tuple such as ("Law of recency") as belonging to the data type of the element (in this case a str). As a result, a type error is thrown when you try to concatenate the thorndike tuple and ("Law of recency").

thorndike = ("Edward", "Lee", "Thorndike", 1874, "Law of effect", "Law of exercise")
thorndike = thorndike[:] + ("Law of recency")

## Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: can only concatenate tuple (not "str") to tuple
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

Python has a very powerful tuple assignment feature that allows a tuple of variable names on the left of the assignment operator = to be assigned to a tuple of values, like so

thorndike = ("Edward", "Lee", "Thorndike", 1874)
(name, middle_name, surname, born) = thorndike
print(name)

## Edward

a, b = "Hello", "World"
print(a)

## Hello

The brackets () are optional in a tuple assignment. Using tuple assignment, you can easily perform several variable assignments in just one line!

4.3 Dictionaries

Dictonaries share similarities with real-life address books where you can find a person’s contact details by looking up his or her name.

address_book = {"studyadviser-PSY": "studyadviser-psy[at]utwente.nl",
                "studentservices" : "studentservices[at]utwente.nl",
                "ICT-helpdesk"   : "servicedesk-ict[at]utwente.nl"
                }

print(address_book["studyadviser-PSY"])

## studyadviser-psy[at]utwente.nl

Dictionaries associate keys (e.g. a name) with values (e.g. contact details). The key:value pairs of a dictionary are separated by commas. Each pair contains a key and a value separated by a colon :. key:value pairs are always one-to-one mappings. This means that you cannot map the same key to several values, like so

address_book = {"studyadviser-PSY": "studyadviser-psy[at]utwente.nl",
                "studyadviser-PSY": "Cubicus, room C116"
                }
                
print(address_book["studyadviser-PSY"])

## Cubicus, room C116

print("Number of key:value pairs in address_book: %d" % len(address_book.keys()))

## Number of key:value pairs in address_book: 1

As you can see, the first mapping of the key "studyadviser-PSY" to "studyadviser-psy[at]utwente.nl" has been overwritten by the second mapping of the key to "Cubicus, room C116". In total, address_book now only contains a single key:value pair. As with lists and tuples, values are arbitrary for dictionaries. This means that while you cannot map the same key to several values, you can map the same value to multiple keys.

address_book = {"studyadviser-PSY": "studyadviser-psy[at]utwente.nl",
                "studyadviser-PSY_email": "studyadviser-psy[at]utwente.nl"
                }
                
print("Number of key:value pairs in address_book: %d" % len(address_book.keys()))

## Number of key:value pairs in address_book: 2

Dictionaries require their keys to be immutable and unique. As you above, you cannot have two keys named "studyadviser-PSY" in the address_book. This also means that certain data types are unsuitable as dictionary keys, like lists.

d = {['a']: 'b'}

## Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: unhashable type: 'list'
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

Whenever you try to use a mutable object (like lists) as a key, a TypeError will be thrown. Because lists are mutable (you can update their elements), they are unhashable. Without going into the details of hash functions here, a hash is another representation of an object. It is a transformation of the object’s length sequence of bytes into a fixed length sequence. Hash functions are used in cryptographic algorithms, in digital signatures, manipulation detection, password storage and more. Hash functions are constructed so that calculating an object’s hash representation is simple, but retrieving the original object is difficult without knowing the function used to hash the object in the first place. You can imagine that things start to get messy if the object itself can change after its hash has been calculated. A hash is a momentary snapshot of an object. It is impossible to retrieve the “latest version” of a changable object from its hash representation, even if you know its hash function. Dictionaries themselves are also mutable (and thus, unhashable) and cannot be used as keys, by the way.

Dictionaries are unordered collections. Dictionaries do not have a sequential representation of their elements. Unlike sequences, such as lists and tuples, the elements of a dictionary cannot be accessed using indices. Values stored in a dictionary can be accessed and changed through their respective keys, like so

address_book = {"studyadviser-PSY": "studyadviser-psy[at]utwente.nl",
                "studentservices" : "studentservices[at]utwente.nl",
                "ICT-helpdesk"   : "servicedesk-ict[at]utwente.nl"
                }
                
address_book["studentservices"] = ("studentservices[at]utwente.nl", "0534892124")
print("The telephone number of the student services is", str(address_book["studentservices"][1]))

## The telephone number of the student services is 0534892124

Apart from updating existing dictionary entries, you can obviously also add and remove entries of a dictionary. Use the del statement to remove dictionary entries.

address_book = {"studyadviser-PSY": "studyadviser-psy@utwente.nl ",
                "studentservices" : "studentservices@utwente.nl",
                "ICT-helpdesk"   : "servicedesk-ict@utwente.nl"
                }
                
address_book["studentUnion"] = "studentunion@union.utwente.nl"
print(address_book)
                

## {'studyadviser-PSY': 'studyadviser-psy@utwente.nl ', 'studentservices': 'studentservices@utwente.nl', 'ICT-helpdesk': 'servicedesk-ict@utwente.nl', 'studentUnion': 'studentunion@union.utwente.nl'}

del address_book["ICT-helpdesk"]
print(address_book)

## {'studyadviser-PSY': 'studyadviser-psy@utwente.nl ', 'studentservices': 'studentservices@utwente.nl', 'studentUnion': 'studentunion@union.utwente.nl'}

4.4 Putting collections to use

Lists, tuples and dictionaries are readily used in interactive programs, such as the Stroop Task program. Collections help structure user input and the subsequent storage of user input in computer memory. Structuring user input makes later retrieval of information easier. Below you see a code snippet from the Stroop Task program.

KEYS     = {"red": K_b,
            "green": K_n,
            "blue": K_m}
RT = []
trial_number = 0    
    
while True:
    pygame.display.get_surface().fill(BACKGR_COL)        

    # Changing states
    for event in pygame.event.get():                        
        if STATE == "welcome":
             if event.type == KEYDOWN and event.key == K_SPACE:
                 STATE = "present_trial"
                 print(STATE)
                    
        if STATE == "present_trial":
             trial_number = trial_number + 1
             this_word  = pick_color()
             this_color = pick_color()
             time_when_presented = time()
             STATE = "wait_for_response"
             print(STATE)
                    
        if STATE == "wait_for_response":
            if event.type == KEYDOWN and event.key in KEYS.values():
                time_when_reacted = time()
                this_reaction_time = time_when_reacted - time_when_presented
                RT.append(this_reaction_time)
                this_correctness = (event.key == KEYS[this_color])
                STATE = "feedback"
                print(STATE)

                
        if STATE == "feedback":
            if event.type == KEYDOWN and event.key == K_SPACE:
                if trial_number < 20:
                    STATE = "present_trial"
                else:
                    STATE = "goodbye"
                print(STATE)
            
        if event.type == QUIT:
            STATE = "quit"

Note how the variable RT is used to keep track of the user’s reaction times throughout the trials. The variable this_reaction_time is overwritten in each trial. This means, that at the end of the program, when all trials are completed, this_reaction_time only contains the last value assigned to it during the 20th trial. All other reaction times were long erased from computer memory. But wait, what if we want to calculate a user’s mean reaction time once the experiment is finished? In order to do so, we need some way of saving the reaction times from trial to trial. They need to persist until the last trial is completed. This is exactly where collections step into the picture. Collections are capable of storing multiple values at the same time and they can be mutated iteratively (one reaction time per trial). Hence, we append the calculated reaction time to a list in each trial.

In the end, you as a programmer still need to decide how to proceed with the collected reaction times. Do you want to print their mean to the screen, export them out of the program, or combine them with data gathered from other experimental subjects? It is up to you. Using collections, at least you have a user’s reaction times at your disposal, even after they completed the experiment.

4.5 Common errors

• The by far most occurring errors involving lists are index out of range errors. I think it is fair to say that they make up a large amount of all programming errors. An index out of range error is thrown when you try to access an index that does not exist in a sequence.

shoppinglist = ["milk", "eggs", "bread", "appels"]
print shoppinglist[4]

## [1] "Error: Missing parentheses in call to 'print'. Did you mean print(shoppinglist[4])? (<string>, line 2)"

You will usually encounter this error as a result of confusing the starting index 0 with 1. Against all intuition, in a list of four elements, the last element is stored at index 3, not at index 4. It helps to keep in mind that the indices of your sequences always have a range one shorter than the number of elements in your list. For a list with four elements, the positive index range is 0 to 4 minus 1, thus 3.

shoppinglist = ["milk", "eggs", "bread", "appels"]
print(shoppinglist[3])

## appels

• Another common mistake surrounding collections concerns the immutability of tuples. In particular, trying to change the content of a tuple will result in a TypeError. Tuples are immutable, meaning that you cannot change their content after their initialization. You can, however, re-assign the variable name of an existing tuple to a new tuple containing different values.

a = (1,2,4)
b[2] = 3

## Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: 'str' object does not support item assignment
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

a = (1,2,4)
print(a)

## (1, 2, 4)

b = (1,2,3)
print(b)

## (1, 2, 3)

• Concerning dictionaries, you will most probably not escape one or another KeyError. A KeyError is thrown when you try to access a key that does not exist in the dictionary.

d = {}
print(d['a'])

## Error in py_call_impl(callable, dots$args, dots$keywords): KeyError: 'a'
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

The same is likely to occur when you try to use indices to access the entries of a dictionary

d = {'a': 1}
print(d[0])

## Error in py_call_impl(callable, dots$args, dots$keywords): KeyError: 0
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

Dictionaries are the only unordered type of collection you encountered in this chapter. It occurs now and then that one assumes that a dictionary can be treated as other common types of collections, such as lists or tuples.

4.6 Debugging

Here are some tips and tricks on how to debug errors that potentially originate from your collections.

1. Regularly checking the length of your collections can be very helpful to confirm that your code does indeed what you expect it to do. Take the example of RT, the list we made to keep track of a participant’s reaction times throughout the Stroop Task program. At the end of the experiment, you would expect the list to contain 20 elements, given that RT was initialized as an empty list and that the experiment had 20 trials. By checking the length of RT, you can immediately see whether your code indeed stored one reaction time per trial. RT should have a length of 20 after the experiment. You can check the length of a collection using the len() method, like so

a = [3, 4]
print(len(a))

## 2

2. Dictionaries have a very useful built-in method that represents their keys as a list.

d = {'a': 1,
     'b': 2}
     
print(d.keys())

## dict_keys(['a', 'b'])

This comes in handy when you keep getting a KeyError while you are convinced that your dictionary should contain a certain key.

d = {'a ': 1,
     'b': 2}
     
print(d['a'])

## Error in py_call_impl(callable, dots$args, dots$keywords): KeyError: 'a'
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

You can use in to check whether a candidate key is among the keys of the dictionary

d = {'a ': 1,
     'b': 2}
     
print('a' in d.keys())

## False

In this case, a typing error is the culprit. Instead of 'a', 'a ' with a whitespace was set as the first key of d.

Alternatively, you can use a simple conditional constructions and not in to make sure that you do not overwrite any existing keys

d = {'a': 1,
     'b': 2}

if 'a' not in d.keys():
    d['a'] = 0

print(d)

## {'a': 1, 'b': 2}

Finally, you should know that the output list produced by the keys() method can be confusing at times. It is possible that your Python interpreter returns a different list of keys than the same code snippet d.keys() produces on another system. This has to do with how dictionaries are stored internally in computer memory. Here as well hash functions are utilized for efficiency reasons. As a result, the order of the keys in a dictionary is unspecified (which is why you cannot use the index operator to access elements of a dictionary). In practice, it means that 'a' is not necessarily the first element in a list produced by d.keys(). Rest assured, in practice, this peculiarity is rather insignificant.

4.7 Exercises

a = [6, 7]
b = [4, 5]
b.append(a)

print(b)

d = {1: 'a',
    'a': 1}
    
print(d[1])

a = [1]
b = ('a', 2)
a.extend(b)

print(a[1])

a, b = (['a', 'd'], ['b', 'c'])

print(b[0])

a = [1, 2, 3]

print(a[-1])

a = (1, 2, [3, 4], 5)

print(a[2][1])

a, b = 'Sigmund', 'Freud', (1856, 1939)

a = [1, 2]
b = (3, 4)

a.append(b)
print(a[3])

a = ('a', [1, 2])

a[1].append(3)

a = {('a', 'b'): 3}

print(a.keys())

a = {}

print(a.keys())

a = []
b = ([1, 2], [3, 4], [5, 6])

a.extend(b)
print(a[1])

a = ('a', ('b', 'c'))

print('b' in a)

a = [{'a': 1 }, {'a': 2}]

if 'a' in a[0]:
    print(a[0]['a'])
elif 'a' in a[1]:
    print(a[1]['a'])
  

shoppinglist = ["bread","cheese","jam","milk","oatmeal","blueberries","oranges","apples"]
shoppinglist[0] = "buns"
shoppinglist = shoppinglist + ["chocolate"]
del shoppinglist[2]

shoppinglist_mum = ["eggs","yoghurt","potatoes","salmon"]
shoppinglist += shoppinglist_mum
del shoppinglist[10]

ingredients_muffins = ["icing sugar","whipping cream","lemons","flower","vanilla sugar","eggs","mandarines","baking powder","sugar","margarine"]

shoppinglist.append(ingredients_muffins)
del shoppinglist[11][6]
shoppinglist[8:11] = [shoppinglist[8:11]]

del ingredients_muffins[7]

famous_psychologists = {"Freud":("Sigmund", "Freud", (1856,1939), "Psychoanalysis"),
                        "Piaget":("Jean", "Piaget", (1896,1980), "Theory of Cognitive Development"),
                        "Skinner":(("Burrhus", "Frederic"), "Skinner", (1904,1990), "Operant Conditioning"),
                        }
                      
erikson = ("Erik", "Erikson", (1902,1994), "Theory of Psychological Development")
famous_psychologists["Erikson"] = erikson

more_on_Skinner = {"Schedules of Reinforcement":("positive reinforcement", "negative reinforcement", "extinction"),
                   "Skinner Box":("pigeon","lever","food"),
                  }
famous_psychologists["Skinner"] = famous_psychologists["Skinner"][:3] + ("Behaviorism",) +         (famous_psychologists["Skinner"][3],) + (more_on_Skinner,)

print(famous_psychologists["Erikson"][:3])
print(famous_psychologists["Piaget"][3:])
print(famous_psychologists["Freud"][2][0])
print(famous_psychologists["Skinner"][0][1])
print(famous_psychologists["Skinner"][5].keys()[1])

word = famous_psychologists["Skinner"][5].keys()[0]
print(famous_psychologists["Skinner"][5][word][0])

dinner = ["minced beef", "tomatoes", "pasta", "onions", "pasta sauce", "courgette"]
shoppingList = [dinner, "bread", "milk", "cornflakes", "cheese"]

grades = {"p1": ("Judith",21,"female","B-PSY",(5.6,7.7,7.3)),
          "p2": ("Menno",19,"male","B-CREATE",(8.6,6.9,7.4)),
          "p3": ("Jan",19,"male","B-CREATE",(3.9,4.5,8.9)),
          "p4": ("Eva",20,"female","B-MATH",(8.0,7.0,9.1)),
          "p5": ("Sophia",22,"female","M-PSY",(4.9,6.7,7.6)),
          "p6": ("Jeroen",25,"male","M-BME",(8.5,8.5,8.5)),
          "p7": ("Max",18,"male","B-IBA",(7.9,2.0,6.5))
         }

dataset = {'p1':[21,"Female","Dutch","B-Psychology",[True,False,True,False,False],5.2],
           'p2':[20,"Female","Dutch","B-Psychology",[True,True,True,False,True],8.4],
           'p3':[21,"Female","Dutch","B-Applied_Mathematics",[False,True,True,False,True],7.8],
           'p4':[23,"Male", "German","B-Communication_Science",[True,True,"n/a","n/a",True],8.8],
           'p5':["n/a","n/a","Dutch","M-Business_Administration",[False,False,True,True,True],7.6],
           'p6':[19,"Male","Swedish","B-Computer_Science",[True,False,False,True,False],7.5],
           'p7':[19,"Male","German","B-Communication_Science",[True,True,False,True,True],5.4]
           }

participants = {participant_no:(gender, age, nationality, profession)}

4.8 Think further

• For more detailed information on lists beyond the scope of this chapter, you are advised to take a look at Wentworth, P., Elkner, J., Downey, A. B., & Meyer, C. (2015). How to think like a computer scientist: Learning with Python 3. Chapter 11. Lists
• For more information on dictionaries, including explanation on useful built-in functions of the dictionary class, you are invited to take a look at Wentworth, P., Elkner, J., Downey, A. B., & Meyer, C. (2015). How to think like a computer scientist: Learning with Python 3. Chapter 20. dictionaries
• More information on tuples can be found in Wentworth, P., Elkner, J., Downey, A. B., & Meyer, C. (2015). How to think like a computer scientist: Learning with Python 3. Chapter 9. Tuples