Book - 5.4) Python- Combining Lists and Dictionaries
Combining Lists and Dictionaries in Python¶
We have seen that combining the two data structures of lists and dictionaries can be done to represent complex arrangements of data. Such complexity is common in real world data sets. We now want to see how to use Python to create and manipulates these complex data sets.
A List of Dictionaries¶
We have also seen that to represent multiple instances of an abstraction with several properties it is necessary to combine lists and dictionaries together. A simple abstraction is shown as a table below. This table visually illustrates the abstraction of the weather forecast for a given city. The weather abstraction has three properties: temperature, humidity and wind. Each row of the table represents a separate instance of the abstraction (i.e. the next day in the forecast).
Because the properties of city, temperature, humidity, and wind are conceptually different and involve different types we would use a dictionary to represent each instance. This involves breaking the abstraction table apart and representing each instance (each row in the abstraction table) by a dictionary. In Python these individual dictionaries are written as:
{ 'humidity' : 20, 'temperature' : 78, 'wind' : 7}
{ 'humidity' : 50, 'temperature' : 61, 'wind' : 10}
{ 'humidity' : 100, 'temperature' : 81, 'wind' : 5}
{ 'humidity' : 90, 'temperature' : 62, 'wind' : 15}
{ 'humidity' : 30, 'temperature' : 84, 'wind' : 19}
{ 'humidity' : 0, 'temperature' : 66, 'wind' : 28}
{ 'humidity' : 0, 'temperature' : 87, 'wind' : 12}
{ 'humidity' : 0, 'temperature' : 68, 'wind' : 14}
{ 'humidity' : 0, 'temperature' : 86, 'wind' : 4}
{ 'humidity' : 60, 'temperature' : 68, 'wind' : 0}
This shows one dictionary for each instance of the abstraction.
The next step is representing the single collection of all instances of the abstraction. In this case we notice that all of the items we want to represent are of the same structure, that is, they are all dictionaries with the same set of keys. The individual dictionaries can then be combined into a single list. In Python, the list of dictionaries would appear as:
Blacksburg_Forecast = [ { 'humidity' : 20, 'temperature' : 78, 'wind' : 7} ,
{ 'humidity' : 50, 'temperature' : 61, 'wind' : 10} ,
{ 'humidity' : 100, 'temperature' : 81, 'wind' : 5} ,
{ 'humidity' : 90, 'temperature' : 62, 'wind' : 15} ,
{ 'humidity' : 30, 'temperature' : 84, 'wind' : 19} ,
{ 'humidity' : 0, 'temperature' : 66, 'wind' : 28} ,
{ 'humidity' : 0, 'temperature' : 87, 'wind' : 12} ,
{ 'humidity' : 0, 'temperature' : 68, 'wind' : 14} ,
{ 'humidity' : 0, 'temperature' : 86, 'wind' : 4} ,
{ 'humidity' : 60, 'temperature' : 68, 'wind' : 0}
]
Notice that adjacent dictionaries are separated by a comma "," symbol.
Because the forecasted weather data is a list iteration can be used to access and manipulate each element of the list. The only difference is that the item selected from the list on each iteration is a complete dictionary. The following Python example shows how to print the wind speed values in each of the weather dictionaries.
for forecast in Blacksburg_Forecast:
wind_speed = forecast['wind']
print(wind_speed)
In this code the expression forecast['wind'] represents the value that is associated with the key 'wind' in the dictionary forecast. At each step in the iteration, forecast denotes the current item in the list Blacksburg_Forecast; each of these items is a complete dictionary. The dictionaries in the list have the same structure: they all have the keys 'temperature', 'humidity', and 'wind'. Each list item has different values associated with these keys.
If we examine the Spyder Variable explorer (see next figure) we can see that the value of the property Blacksburg_Forecast is of type List and has a value consisting of a sequence of weather dictionaries. It can also be seen that each element of the list is of type Dictionary. Each of these dictionaries has the three keys 'humidity', 'temperature', and 'wind'.
Python Lists and Dictionaries
Dictionaries with List Values¶
So far our example dictionaries have used key-value pairs where the value is a single basic type. For example, the temperature property is a single whole number, the crime rate is a single number with a decimal point, the name of a city is a single string. However, more intricate arrangements are possible - and needed.
We will now see that a dictionary’s key can have a list as its value. A simple example illustrating a property with a list value is the abstraction of a temperature forecast that separates the high temperatures that are forecast from the low temperatures that are forecast. This abstraction has two properties: highs and lows as shown in the following figure. The value associated with the highs property is a list of forecasted high temperatures. The lows property is a list of forecasted low temperatures. Each temperature is represented by a single whole number (i.e., an int type).
Dictionary Keys with List Values
In Python the function in the Weather module named “get_highs_and _lows” returns the forecasted high and low temperatures for the selected city. The following Python code show an algorithm to create a line drawing of the high and low temperatures for a given city on the same plot.
import weather
import matplotlib.pyplot as plt
highs_lows = weather.get_highs_lows("Blacksburg, VA")
print(highs_lows)
plt.plot(highs_lows["highs"])
plt.plot(highs_lows["lows"])
plt.title("High and Low Temperatures")
plt.show()
The structure of the dictionary with list values is shown by Spyder's Variable explorer. The property highs_lows in the above code is shown in the next figure. As shown in the figure each of the two keys 'highs' and 'lows' has as its value a list of 5 elements.
Viewing a Dictionary with List Values
The graph produced by the above program is shown below. In this figure the blue line denotes the high temperature values and the green line denotes the low temperature values.
More Complex Combinations¶
Having seen that lists and dictionaries can be combined individually we now want to see that these two data structures can be combined in multiple ways to represent an abstraction. This idea will be explored in more depth as Layers of Abstraction.
Consider the example shown in the following figure that is an abstraction of a national weather forecast. In this abstraction, each instance is an abstraction of the forecast for a particular city. The city forecast abstraction has two properties: city and forecast. The forecasts property gives the list of forecasted temperatures for the corresponding city.
To represent this abstraction as a data structure we will need:
- a list each element of which is an instance of the city forecast abstraction
- a dictionary to represent each city forecast abstraction; the dictionary has the two keys city and forecasts
- a list to represent the forecasted temperatures for a given city; this list is the value of the key forecasts in the dictionary representing the city forecast abstraction.
Notice that with this organization we can meaningfully say:
- The national weather forecast abstraction is a list of city forecasts abstractions
- Each city forecast abstraction contains a list of temperatures
The following Python example shows an algorithm that will will create a line drawing of the forecast for each city in the national weather report. Notice that on each iteration, the value of the property City Report is a dictionary with the keys city and forecasts. In this algorithm the list of temperatures is accessed using the forecasts key. This list of temperatures is plotted. The name of the city is accessed the city key. The name of the city is printed.
import weather
import matplotlib.pyplot as plt
National_Weather_Report = weather.get_all_forecasted_temperatures()
for City_Report in National_Weather_Report:
print(City_Report['city'])
plt.plot(City_Report['forecasts'])
plt.title("National Weather Forecast")
plt.show()
The graph produced by this code is seen in the following figure. The names of the cities that are printed are now shown but do appear in the Spydere console window.