Class 1 for course: "Programming, data analysis & data visualization in python". A course for the Champlimaud Neuroscience Program.

1. lists and
(the amazing)
dictionaries

2. The plan!
Basics: data types (and operations & calculations)
Basics: conditionals & iteration
Basics: lists, tuples, dictionaries
Basics: writing functions
Reading & writing files: opening, parsing & formats
Working with numbers: numpy & scipy
Making plots: matplotlib & pylab
… if you guys want more after all of that …
Writing better code: functions, pep8, classes
Working with numbers: Numpy & Scipy (advanced)
Other modules: Pandas & Scikit-learn
Interactive notebooks: ipython & jupyter
Advanced topics: virtual environments & version control

3. data types for multiple things...
lists
[ 1, 2, 3, 100, 99 , 50]
strings
"wait, we already know these!"
tuples
(10, 11, 12, 100, 90, 80)
dictionaries
{"name": "Bob", "age": 33}

4. lists
# define a list:
mylist = [5, 3, 1, "a", [12, 14, 16],]
# indexing and slicing:
print mylist[2]
print mylist[:4]
# changing elements
mylist[2] = 300
print mylist
Using an existing list with methods:
mylist.method()
Finding things:
.index(element) ← first only
.count(element)
Removing things:
.pop(<pos>) ← returns element
.remove(element)
Adding things:
.append(element)
.insert(pos, element)
.extend(newlist)
also useful: len(list)
copying lists: list2 = list(list1)

5. lists, loops and conditionals
---- somefile.py ----
# lets take a close look at "range":
a = range(10)
print type(a) # (note: different in python 3)

6. lists, loops and conditionals
---- somefile.py ----
# lets take a close look at "range":
a = range(10)
print type(a) # (note: different in python 3)
# using lists in loops:
somelist = [1, 2, "a", "b", "hello", 3.0, 99]
for element in somelist:
print element, "is of type:", type(element)

7. lists, loops and conditionals
---- somefile.py ----
# lets take a close look at "range":
a = range(10)
print type(a) # (note: different in python 3)
# using lists in loops:
somelist = [1, 2, "a", "b", "hello", 3.0, 99]
for element in somelist:
print element, "is of type:", type(element)
# using lists in conditionals:
if "a" in somelist:
print "a is in the list"
Using in with lists:
for var in list:
do stuff in loop
if var in list:
do "True" block
else:
do "False" block

8. lists, loops and conditionals
---- somefile.py ----
# lets take a close look at "range":
a = range(10)
print type(a) # (note: different in python 3)
# using lists in loops:
somelist = [1, 2, "a", "b", "hello", 3.0, 99]
for element in somelist:
print element, "is of type:", type(element)
# using lists in conditionals:
if "a" in somelist:
print "a is in the list"
# using lists in tests and conditionals:
mylist = [1, 2, "a", "b", "hello", 99]
for a in range(100):
if a in mylist:
print a, "is in the list!"
Using in with lists:
for var in list:
do stuff in loop
if var in list:
do "True" block
else:
do "False" block

9. - you can download this from our drive: hamcakes_script
- How many ingredients are there in total (in the snack)?
- Are there any in the "snack" which are not in "pancakes" or "hamburger"? (add
these to the correct list)
- By majority vote: is it a pancake or hamburger?
hamcake!
# you should be able to copy-paste this :)
snack = [
"chocolate", "strawberries", "salad", "chocolate", "salad", "cheese", "cream", "cheese", "tomatoes", "bacon", "bacon", "tomatoes", "burger", "onions", "cheese",
"banana", "pineapple", "tomatoes", "bacon", "cheese", "burger", "salad", "tomatoes", "onions", "chocolate", "pineapple", "tomatoes", "onions", "salad",
"strawberries",
"egg", "cheese", "tomatoes", "burger", "bacon", "cream", "sugar", "burger", "ketchup", "salad", "chocolate", "cream", "egg", "sugar", "salad", "pineapple", "bacon",
"cheese", "bacon",
]
pancake = [ "chocolate", "strawberries", "chocolate", "cream", "pineapple", "sugar",]
hamburger = [ "tomatoes", "bacon", "cheese", "burger", "salad", "onions", "egg", ]

10. dictionaries!
---- animals.py ----
# Creating a dictionary. Note the use of "{" and "}"
# The ":" separates pairs of "keys" and "values"
sounds = {"cat": "meow", "dog": "woof"}

11. dictionaries!
---- animals.py ----
# Creating a dictionary. Note the use of "{" and "}"
# The ":" separates pairs of "keys" and "values"
sounds = {"cat": "meow", "dog": "woof"}
Creating a dictionary:
var = { key-1: value-1, key-2: value-2 … }
keys: Can be strings or numbers (integers, floats).
(or even tuples!)
values: Can be any valid python object

12. dictionaries!
---- animals.py ----
# Creating a dictionary. Note the use of "{" and "}"
# The ":" separates pairs of "keys" and "values"
sounds = {"cat": "meow", "dog": "woof"}
# using the key to find a value
print sounds["cat"]
# adding and changing an element
sounds["cow"] = "quack"
print sounds
# keys can be strings, ints, floats, or even tuples
sounds[5] = "highfive!"
print sounds
# keys can be strings, ints, floats, or even tuples
sounds[13] = ["llama", 8, "potato"]
print sounds
Creating a dictionary:
var = { key-1: value-1, key-2: value-2 … }
keys: Can be strings or numbers (integers, floats).
(or even tuples!)
values: Can be any valid python object

13. dictionaries!
---- animals.py ----
# Creating a dictionary. Note the use of "{" and "}"
# The ":" separates pairs of "keys" and "values"
sounds = {"cat": "meow", "dog": "woof"}
# using the key to find a value
print sounds["cat"]
# adding and changing an element
sounds["cow"] = "quack"
print sounds
# keys can be strings, ints, floats, or even tuples
sounds[5] = "highfive!"
print sounds
# keys can be strings, ints, floats, or even tuples
sounds[13] = ["llama", 8, "potato"]
print sounds
Creating a dictionary:
var = { key-1: value-1, key-2: value-2 … }
keys: Can be strings or numbers (integers, floats).
(or even tuples!)
values: Can be any valid python object

14. dictionaries!
---- animals.py ----
# Creating a dictionary. Note the use of "{" and "}"
# The ":" separates pairs of "keys" and "values"
sounds = {"cat": "meow", "dog": "woof"}
# using the key to find a value
print sounds["cat"]
# adding and changing an element
sounds["cow"] = "quack"
print sounds
# keys can be strings, ints, floats, or even tuples
sounds[5] = "highfive!"
print sounds
# keys can be strings, ints, floats, or even tuples
sounds[13] = ["llama", 8, "potato"]
print sounds
Creating a dictionary:
var = { key-1: value-1, key-2: value-2 … }
keys: Can be strings or numbers (integers, floats).
(or even tuples!)
values: Can be any valid python object
dictionaries are not ordered!

15. dictionaries!
---- animals.py (cont) ----
# updating an existing dictionary
jungle = {"tiger": "roar", "elephant": "fwaaaap"}
sounds.update(jungle)
print sounds
# accessing keys and values
print sounds.keys()
vals = sounds.value()
print vals
print type(vals)
print sounds.items()
# deleting an entry
print sounds
del sounds["tiger"]
print sounds
# oh yeah.. the len of a dict:
print len(sounds)
Dictionary methods:
mydict.method()
Adding one dictionary to another:
.update(dict)
Accessing keys/values:
.keys()
.values()
.items()
Not methods, but useful too:
len(dict)
del dict[‘key’]

16. copying dictionaries
---- file contents ----
# making a copy of a dictionary:
dict1 = {1: 2, 3: 12}
dict2 = dict1
dict3 = dict1.copy()
dict1["extra"] = "things"
print dict1
print dict2
print dict3
"=" does not copy a dict!
dict2 = dict1 ← are the same dict
… use:
dict2 = d.copy()

17. loops + dictionaries!
---- animals.py (cont) ----
sounds = {"cat": "meow", "dog": "woof", "tiger": "roar", "elephant": "fwaaaap"}
# looping over all keys
keys = sounds.keys()
for key in keys:
print “Looping to animal:”, key

18. loops + dictionaries!
---- animals.py (cont) ----
sounds = {"cat": "meow", "dog": "woof", "tiger": "roar", "elephant": "fwaaaap"}
# looping over all keys
keys = sounds.keys()
for key in keys:
print “Looping to animal:”, key
# looping over all values
values = sounds.values()
for val in values:
print “A noise is:”, val
# looping over all keys (again)
for key in sounds.keys():
print “The”, key, “says:” sound[key]
# looping over all key/value pairs
for key, value in sounds.items():
print “The”, key, “says:” value
Dictionaries in loops:
for key in mydict.keys():
Loop over keys
for value in mydict.values():
Loop over values
for key, value in mydict.items():
Loop over key/value pairs
for key in mydict:
Shorthand to loop over keys

19. loops + dictionaries!
---- animals.py (cont) ----
sounds = {"cat": "meow", "dog": "woof", "tiger": "roar", "elephant": "fwaaaap"}
# checking if a key exists:
if “cat” in sounds:
print “Cat is in sounds.”
# by default, this only works for keys
if “meow” in sounds:
print “Meow is in sounds”
else:
print “Meow is NOT in sounds”
# if we need to check values, use values()
if “meow” in sounds.values:
print “Meow is in sounds (a value)”
else:
print “Meow is NOT in sounds (values)”
Dictionaries in loops:
if key in mydict:
check if key is in the dictionary

20. 1. Write a script that prints the song.
Animal Orchestra:
# you should be able to copy-paste this :)
sounds = {"cat": "meow", "dog": "woof", "squirrel": "braaaap"}
song = ["dog", "cat", "dog", "squirrel", "dog", "cat", "dog", "squirrel", "dog", "squirrel",]

21. 1. Write a script that prints the song.
2. Elvis (the squirrel) has left the building! Modify the script to write the song as
before, but leave an empty space when Elvis’ part should have been (use key in
dict).
Animal Orchestra:
# you should be able to copy-paste this :)
sounds = {"cat": "meow", "dog": "woof", "squirrel": "braaaap"}
song = ["dog", "cat", "dog", "squirrel", "dog", "cat", "dog", "squirrel", "dog", "squirrel",]

22. 1. Write a script that prints the song.
2. Elvis (the squirrel) has left the building! Modify the script to write the song as
before, but leave an empty space when Elvis’ part should have been (use key in
dict).
3. The replacement has arrived! Prompt the user for the sound that the new squirrel
names. Update the dictionary to reflect these changes, and write the new song.
Animal Orchestra:
# you should be able to copy-paste this :)
sounds = {"cat": "meow", "dog": "woof", "squirrel": "braaaap"}
song = ["dog", "cat", "dog", "squirrel", "dog", "cat", "dog", "squirrel", "dog", "squirrel",]