Contents | Previous (2.1 Datatypes) | Next (2.3 Formatting)
This section discusses lists, dictionaries, and sets.
Programs often have to work with many objects.
- A portfolio of stocks
- A table of stock prices
There are three main choices to use.
- Lists. Ordered data.
- Dictionaries. Unordered data.
- Sets. Unordered collection of unique items.
Use a list when the order of the data matters. Remember that lists can hold any kind of object. For example, a list of tuples.
portfolio = [
('GOOG', 100, 490.1),
('IBM', 50, 91.3),
('CAT', 150, 83.44)
]
portfolio[0] # ('GOOG', 100, 490.1)
portfolio[2] # ('CAT', 150, 83.44)Building a list from scratch.
records = [] # Initial empty list
# Use .append() to add more items
records.append(('GOOG', 100, 490.10))
records.append(('IBM', 50, 91.3))
...An example when reading records from a file.
records = [] # Initial empty list
with open('Data/portfolio.csv', 'rt') as f:
next(f) # Skip header
for line in f:
row = line.split(',')
records.append((row[0], int(row[1]), float(row[2])))Dictionaries are useful if you want fast random lookups (by key name). For example, a dictionary of stock prices:
prices = {
'GOOG': 513.25,
'CAT': 87.22,
'IBM': 93.37,
'MSFT': 44.12
}Here are some simple lookups:
>>> prices['IBM']
93.37
>>> prices['GOOG']
513.25
>>>Example of building a dict from scratch.
prices = {} # Initial empty dict
# Insert new items
prices['GOOG'] = 513.25
prices['CAT'] = 87.22
prices['IBM'] = 93.37An example populating the dict from the contents of a file.
prices = {} # Initial empty dict
with open('Data/prices.csv', 'rt') as f:
for line in f:
row = line.split(',')
prices[row[0]] = float(row[1])Note: If you try this on the Data/prices.csv file, you'll find that
it almost works--there's a blank line at the end that causes it to
crash. You'll need to figure out some way to modify the code to
account for that (see Exercise 2.6).
You can test the existence of a key.
if key in d:
# YES
else:
# NOYou can look up a value that might not exist and provide a default value in case it doesn't.
name = d.get(key, default)An example:
>>> prices.get('IBM', 0.0)
93.37
>>> prices.get('SCOX', 0.0)
0.0
>>>Almost any type of value can be used as a dictionary key in Python. A dictionary key must be of a type that is immutable. For example, tuples:
holidays = {
(1, 1) : 'New Years',
(3, 14) : 'Pi day',
(9, 13) : "Programmer's day",
}Then to access:
>>> holidays[3, 14]
'Pi day'
>>>Neither a list, a set, nor another dictionary can serve as a dictionary key, because lists and dictionaries are mutable.
Sets are collection of unordered unique items.
tech_stocks = { 'IBM','AAPL','MSFT' }
# Alternative syntax
tech_stocks = set(['IBM', 'AAPL', 'MSFT'])Sets are useful for membership tests.
>>> tech_stocks
set(['AAPL', 'IBM', 'MSFT'])
>>> 'IBM' in tech_stocks
True
>>> 'FB' in tech_stocks
False
>>>Sets are also useful for duplicate elimination.
names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO']
unique = set(names)
# unique = set(['IBM', 'AAPL','GOOG','YHOO'])Additional set operations:
unique.add('CAT') # Add an item
unique.remove('YHOO') # Remove an item
s1 = { 'a', 'b', 'c'}
s2 = { 'c', 'd' }
s1 | s2 # Set union { 'a', 'b', 'c', 'd' }
s1 & s2 # Set intersection { 'c' }
s1 - s2 # Set difference { 'a', 'b' }In these exercises, you start building one of the major programs used
for the rest of this course. Do your work in the file Work/report.py.
The file Data/portfolio.csv contains a list of stocks in a
portfolio. In Exercise 1.30, you
wrote a function portfolio_cost(filename) that read this file and
performed a simple calculation.
Your code should have looked something like this:
# pcost.py
import csv
def portfolio_cost(filename):
'''Computes the total cost (shares*price) of a portfolio file'''
total_cost = 0.0
with open(filename, 'rt') as f:
rows = csv.reader(f)
headers = next(rows)
for row in rows:
nshares = int(row[1])
price = float(row[2])
total_cost += nshares * price
return total_costUsing this code as a rough guide, create a new file report.py. In
that file, define a function read_portfolio(filename) that opens a
given portfolio file and reads it into a list of tuples. To do this,
you’re going to make a few minor modifications to the above code.
First, instead of defining total_cost = 0, you’ll make a variable
that’s initially set to an empty list. For example:
portfolio = []Next, instead of totaling up the cost, you’ll turn each row into a tuple exactly as you just did in the last exercise and append it to this list. For example:
for row in rows:
holding = (row[0], int(row[1]), float(row[2]))
portfolio.append(holding)Finally, you’ll return the resulting portfolio list.
Experiment with your function interactively (just a reminder that in
order to do this, you first have to run the report.py program in the
interpreter):
Hint: Use -i when executing the file in the terminal
>>> portfolio = read_portfolio('Data/portfolio.csv')
>>> portfolio
[('AA', 100, 32.2), ('IBM', 50, 91.1), ('CAT', 150, 83.44), ('MSFT', 200, 51.23),
('GE', 95, 40.37), ('MSFT', 50, 65.1), ('IBM', 100, 70.44)]
>>>
>>> portfolio[0]
('AA', 100, 32.2)
>>> portfolio[1]
('IBM', 50, 91.1)
>>> portfolio[1][1]
50
>>> total = 0.0
>>> for s in portfolio:
total += s[1] * s[2]
>>> print(total)
44671.15
>>>This list of tuples that you have created is very similar to a 2-D
array. For example, you can access a specific column and row using a
lookup such as portfolio[row][column] where row and column are
integers.
That said, you can also rewrite the last for-loop using a statement like this:
>>> total = 0.0
>>> for name, shares, price in portfolio:
total += shares*price
>>> print(total)
44671.15
>>>Take the function you wrote in Exercise 2.4 and modify to represent each stock in the portfolio with a dictionary instead of a tuple. In this dictionary use the field names of "name", "shares", and "price" to represent the different columns in the input file.
Experiment with this new function in the same manner as you did in Exercise 2.4.
>>> portfolio = read_portfolio('Data/portfolio.csv')
>>> portfolio
[{'name': 'AA', 'shares': 100, 'price': 32.2}, {'name': 'IBM', 'shares': 50, 'price': 91.1},
{'name': 'CAT', 'shares': 150, 'price': 83.44}, {'name': 'MSFT', 'shares': 200, 'price': 51.23},
{'name': 'GE', 'shares': 95, 'price': 40.37}, {'name': 'MSFT', 'shares': 50, 'price': 65.1},
{'name': 'IBM', 'shares': 100, 'price': 70.44}]
>>> portfolio[0]
{'name': 'AA', 'shares': 100, 'price': 32.2}
>>> portfolio[1]
{'name': 'IBM', 'shares': 50, 'price': 91.1}
>>> portfolio[1]['shares']
50
>>> total = 0.0
>>> for s in portfolio:
total += s['shares']*s['price']
>>> print(total)
44671.15
>>>Here, you will notice that the different fields for each entry are accessed by key names instead of numeric column numbers. This is often preferred because the resulting code is easier to read later.
Viewing large dictionaries and lists can be messy. To clean up the
output for debugging, consider using the pprint function.
>>> from pprint import pprint
>>> pprint(portfolio)
[{'name': 'AA', 'price': 32.2, 'shares': 100},
{'name': 'IBM', 'price': 91.1, 'shares': 50},
{'name': 'CAT', 'price': 83.44, 'shares': 150},
{'name': 'MSFT', 'price': 51.23, 'shares': 200},
{'name': 'GE', 'price': 40.37, 'shares': 95},
{'name': 'MSFT', 'price': 65.1, 'shares': 50},
{'name': 'IBM', 'price': 70.44, 'shares': 100}]
>>>A dictionary is a useful way to keep track of items where you want to look up items using an index other than an integer. In the Python shell, try playing with a dictionary:
>>> prices = { }
>>> prices['IBM'] = 92.45
>>> prices['MSFT'] = 45.12
>>> prices
... look at the result ...
>>> prices['IBM']
92.45
>>> prices['AAPL']
... look at the result ...
>>> 'AAPL' in prices
False
>>>The file Data/prices.csv contains a series of lines with stock prices.
The file looks something like this:
"AA",9.22
"AXP",24.85
"BA",44.85
"BAC",11.27
"C",3.72
...
Write a function read_prices(filename) that reads a set of prices
such as this into a dictionary where the keys of the dictionary are
the stock names and the values in the dictionary are the stock prices.
To do this, start with an empty dictionary and start inserting values into it just as you did above. However, you are reading the values from a file now.
We’ll use this data structure to quickly lookup the price of a given stock name.
A few little tips that you’ll need for this part. First, make sure you
use the csv module just as you did before—there’s no need to
reinvent the wheel here.
>>> import csv
>>> f = open('Data/prices.csv', 'r')
>>> rows = csv.reader(f)
>>> for row in rows:
print(row)
['AA', '9.22']
['AXP', '24.85']
...
[]
>>>The other little complication is that the Data/prices.csv file may
have some blank lines in it. Notice how the last row of data above is
an empty list—meaning no data was present on that line.
There’s a possibility that this could cause your program to die with
an exception. Use the try and except statements to catch this as
appropriate. Thought: would it be better to guard against bad data with
an if-statement instead?
Once you have written your read_prices() function, test it
interactively to make sure it works:
>>> prices = read_prices('Data/prices.csv')
>>> prices['IBM']
106.28
>>> prices['MSFT']
20.89
>>>Tie all of this work together by adding a few additional statements to
your report.py program that computes gain/loss. These statements
should take the list of stocks in Exercise 2.5 and the dictionary of
prices in Exercise 2.6 and compute the current value of the portfolio
along with the gain/loss.