How Will You Tell the Story?

Deciding what story you’d like to tell is just as important as deciding how to tell it. You can use charts, graphs, timelines, maps, videos, words, and interactives. You can publish it online or present it at a meeting or conference. You can upload it to a video sharing site. Whatever you choose, make sure the way you are telling the story enhances your findings. There is nothing more disheartening than seeing a presentation so poor it actually nullifies the story it attempts to tell.

In the next few sections, we will evaluate how your audience, your story, and the platforms available affect your presentation choices. We recommend reading through all of them, even if you already have an idea of how you’d like to present your findings. This will give you a greater understanding of what’s available even if you stick with your initial choice. A combination of several formats can be the best option for those trying to reach a larger audience.

Determining how often you plan to update the data in the future is another part of how you tell the story. Is this an ongoing series? Can your audience expect to hear more about this story soon, or in an annual report? Can you tell them clearly when and how it will be updated? Keeping an audience waiting is only a good idea if you can clarify their expectations.

Know Your Audience

Who you are writing for is almost as important as what you are writing. By identifying your target audience, you can determine what they already know about a topic, what is of most interest to them, and how they learn best. Missing the mark in terms of communicating with your audience creates a story without an interested party.

If your reporting or presentation is part of your job, it should be fairly easy to determine your audience. Whether it’s a small group at work, an executive team, or a daily or annual publication, you know exactly who will be reading your reporting.

If you’re not sure which audience to target, one good strategy is to approach different people you know who have markedly different levels of interest in your chosen topic, say, a parent or mentor, a peer, and a mentee (in terms of exposure to the world and your topic). Is one part of the story more interesting to different people, depending on their level of knowledge about the topic? Do different questions come up depending on the age and experience of your audience? Observe their questions and reactions once you explain your topic and amend your target audience interpretation based on these observations.

Once you’ve determined your target audience, you can find out more about them. Use the tips in the following sidebar to help refine how you might tell the story depending on your audience.

Once you’ve found your audience and taken some time to begin your storytelling, you can start investigating ways to tell your data’s story through visualization.

Charts

Charts are a great way to share numeric data, especially when comparing divergent datasets or different groupings. If you have a clear trend in your data or your data shows specific outliers, charts help communicate those observations to your audience.

You can use a stacked or bar chart to show a large number of figures alongside one another. For example, in his Washington Post story on infant mortality, Christopher Ingraham uses a bar chart to compare countries alongside one another.

To show trends over time, one usually employs a line chart. Ingraham also uses a line chart to compare infant mortality rates at different ages. The bar graph helps us see that the United States lags behind most other countries in infant care. The line chart allows us to compare mortality rates in different countries over time, giving us another way to observe the data.

You will note the author chose to only show a few countries on the line chart rather than all of the countries represented in the bar graph. Why do you think he made this decision? It’s possible he reviewed the data and found including more countries made the chart hard to read.

These are the types of decisions you will need to make when visualizing your findings. In order to better determine whether a chart is right for you and what kind of chart is most useful, first define what you’d like to show with your charts. The easy-to-use flowchart available on the Extreme Presentation blog is one place to start when first thinking about these issues. Juice Labs has built an interactive chart selector showing some of the same concepts.

Let’s think about the data we’ve investigated so far and use some built-in agate features to chart the data.

Charting with matplotlib

One of the main Python charting and imaging libraries is matplotlib, which helps chart and plot datasets. It’s a great way to generate simple charts, and the more parts of the plotting library you learn, the more advanced your graphs and charts will be. First, we need to install it by running pip install matplotlib.

Let’s show our perceived corruption scores compared to the child labor percentages. Here’s how we’d do that:

import matplotlib.pyplot as plt

plt.plot(africa_cpi_cl.columns['CPI 2013 Score'],
           africa_cpi_cl.columns['Total (%)']) 

plt.xlabel('CPI Score - 2013') 
plt.ylabel('Child Labor Percentage')
plt.title('CPI & Child Labor Correlation') 

plt.show() 

Uses pylab’s plot method to pass the x and y label data. The first variable passed is the x-axis and the second variable is the y-axis. This creates a Python chart plotting those two datasets.

Calls the xlabel and ylabel methods to label our chart axes.

Calls the title method to title our chart.

Calls the show method to draw the chart. Everything we set up with our chart before we call show will be displayed in the system’s default image program (like Preview or Windows Photo Viewer). Our title, axis labels, and any other attributes we set via the matplotlib library will be displayed in the chart.

And voilà! Python renders the chart shown in Figure 10-1.¹

Figure 10-1. Child labor and CPI chart

We can indeed see the overall downward trend, but we can also see the data in the middle does not follow a particular trend. In fact, the data varies greatly, telling us there is not a connection between child labor and perceived corruption for all of the countries, but only for some of them.

Let’s make the same chart using only the worst offenders. We already separated out these worst offenders, in “Separating and Focusing Your Data”. When we run the previous code again with our highest_cpi_cl table, we see the chart shown in Figure 10-2.

Figure 10-2. Highest child labor chart

Now we can see a clear downward trend for the worst offenders, followed by some anomalies as the child labor rates and perceived corruption scores decrease.

There are many chart types available from pylab, including histograms, scatter charts, bar graphs, and pie charts. We strongly recommend taking a look at matplotlib.org’s introduction to pyplot, covering how to change different aspects of your charts (color, labels, size) and use multiple figures, subplots, and more chart types.

Note

Charting your data can give you a good idea of anomalies or outliers within your dataset. Using the different charting methods available to you in the Python charting libraries can help you research your data’s story and interrelatedness.

The more you play with the library’s charting toolset, the easier it will be to understand which charts work best with your dataset.

Charting with Bokeh

Bokeh is a Python charting library with fairly simple commands for more complex chart types. If you want to create a stacked chart, scatter chart, or time series, we recommend playing around with Bokeh and seeing if it’s right for you. Let’s try making a scatter chart with Bokeh for our CPI and child labor data on a country-by-country basis. Install Bokeh by running this command:

pip install bokeh

Then build a scatter chart with some simple commands using the agate table:

from bokeh.plotting import figure, show, output_file


def scatter_point(chart, x, y, marker_type): 
    chart.scatter(x, y, marker=marker_type, line_color="#6666ee",
                  fill_color="#ee6666", fill_alpha=0.7, size=10) 


chart = figure(title="Perceived Corruption and Child Labor in Africa") 
output_file("scatter_plot.html") 
for row in africa_cpi_cl.rows:
    scatter_point(chart, float(row['CPI 2013 Score']),
                  float(row['Total (%)']), 'circle') 
show(chart) 

Defines a function, scatter_point, which takes a chart, x-axis and y-axis values, and marker type (circle, square, rectangle) and adds the point to the chart.

The chart’s scatter method takes two required arguments (x- and y-axis) and a variety of keyword arguments to style those points (including the color, opacity, and size). This line passes some line colors and fill colors as well as size and opacity settings.

Creates the chart using the figure function and passes a title.

Defines what file to output using the output_file function. This will create the file scatter_plot.html in the folder where you run the code.

For each row, adds a point using the CPI score as the x-axis and the child labor percentage as the y-axis.

Shows the chart in a browser window.

When you run the code, it opens a tab in your browser containing the chart (Figure 10-3).

Figure 10-3. CPI and child labor scatter plot

That’s pretty nice, but we can’t see much about what those dots mean. Bokeh can add interactive elements in our charts. Let’s try adding some:

from bokeh.plotting import ColumnDataSource, figure, show, output_file
from bokeh.models import HoverTool 

TOOLS = "pan,reset,hover" 


def scatter_point(chart, x, y, source, marker_type): 
    chart.scatter(x, y, source=source,
                  marker=marker_type, line_color="#6666ee",
                  fill_color="#ee6666", fill_alpha=0.7, size=10)

chart = figure(title="Perceived Corruption and Child Labor in Africa",
               tools=TOOLS) 
output_file("scatter_int_plot.html")
for row in africa_cpi_cl.rows:
    column_source = ColumnDataSource(
        data={'country': [row['Country / Territory']]}) 
    scatter_point(chart, float(row['CPI 2013 Score']),
                  float(row['Total (%)']), column_source, 'circle')

hover = chart.select(dict(type=HoverTool)) 

hover.tooltips = [
    ("Country", "@country"), 
    ("CPI Score", "$x"),
    ("Child Labor (%)", "$y"),
]

show(chart)

Imports the main libraries we have been using and adds the ColumnDataSource and HoverTool classes.

Defines the tools you’d like to use for the final product. This code adds hover so we can use the hover methods.

Adds source to the required variables. This will hold our country name information.

Passes the TOOLS variable to our figure upon initialization.

column_source now holds a data source dictionary with the country name. This line passes the name as a list because the values must be iterable objects.

Selects the HoverTool object from the chart.

Uses the tooltips method of the hover object to show different data attributes. @country selects the data passed via the column source, whereas $x and $y selects the x and y points on the chart.

Now your chart should look like Figure 10-4.

Figure 10-4. CPI and child labor interactive scatter plot

Note

As you move your cursor over each point, the data for x and y change. To improve the chart, try adding the exact values for our two data points to the column_source object by entering new keys and values into the data dictionary.

Bokeh has a great gallery of examples and code available to help you get started. We recommend taking time with your charts and giving Bokeh a try.

Time-Related Data

Time series and timeline data help represent your findings over time. Time series charts show data changing over time (usually as a line chart, bar chart, or histogram). Timelines allow you to visually tell the story of the data by marking events, occurrences, and changes over time.

Maps

If your findings focus on geography, a map is a great way to present your data. Maps help people identify the impact of a topic on people and regions they know. Depending on how much your audience knows about the area or region you are discussing, you might need to include extra information and context with your map to help relate the story to more familiar regions.

If it’s a local audience, you might include references to locally known monuments and street names. If it’s an international audience and the story covers a particular region (e.g., Amazon deforestation), first reference continental maps and then focus in on your target area.

One example of a newsworthy map is The New York Times’s vaccinations in California map. Published during the recent measles outbreak in California, it gives the readers the ability to zoom in and out for more details, provides short anecdotes, and shows differences between personal belief exemptions and other causes for low vaccination rates (such as poverty or lack of access). By focusing only on California, the map is able to show a level of detail that on a nationwide or regional scale could be too cluttered or complicated.

One example of a larger geographic area map is The Economist’s global debt clock. This map shows public debt on a country-by-country basis with an interactive timeline to examine changes in public debt over time. Its complementary color scheme makes the map easy to read, and one can easily differentiate between heavily indebted countries and those with little or no debt.

There is a very easy-to-use chart and mapping Python library called pygal with great built-in mapping features. pygal has documentation for everything from pie charts and scatter plots to world and country maps. We can use pygal with our agate table to show the worldwide child labor rates. First, we need to install the library and its dependencies by running these commands:

pip install pygal
pip install pygal_maps_world
pip install cssselect
pip install cairosvg
pip install tinycss
pip install lxml

In the pygal world map documentation, we see the two-character ISO codes for every country are necessary to properly map using the world map. We can add these to our ranked table using methods we already know:

import json

country_codes = json.loads(open('iso-2.json', 'rb').read()) 
country_dict = {}

for c in country_codes:
    country_dict[c.get('name')] = c.get('alpha-2') 

def get_country_code(row):
    return country_dict.get(row['Countries and areas']) 

ranked = ranked.compute([('country_code',
                          agate.Formula(text_type, get_country_code)), ])

for r in ranked.where(lambda x: x.get('country_code') is None).rows: 
    print r['Countries and areas']

Loads the string from the iso-2.json file we downloaded from @lukes on GitHub. This file is available in the book’s repository.

Creates a country dictionary where the keys are the country names and the values are the ISO codes.

Defines a new function get_country_code which will take a row of data and return the country code using the country_dict object. If there is no match, it will return None.

Evaluates which ones we couldn’t find matches for so we can further investigate.

You should see output like this:

Bolivia (Plurinational State of)
Cabo Verde
Democratic Republic of the Congo
Iran (Islamic Republic of)
Republic of Moldova
State of Palestine
The former Yugoslav Republic of Macedonia
United Republic of Tanzania
Venezuela (Bolivarian Republic of)

We found most matches, but there are still a few missing. As we did with our earth.json file in the previous chapter, we corrected the matches manually by modifying the names in the data file for the mismatched countries. The cleaned file, iso-2-cleaned.json, is also available in the repository. Now we can use the preceding code with the new, cleaned JSON to make a complete table. Note, you will have to either rename your columns or use the new column name country_code_complete so you don’t run into duplicate column name issues. We will utilize the table to create our own world map using the pygal mapping methods:

import pygal

worldmap_chart = pygal.maps.world.World() 
worldmap_chart.title = 'Child Labor Worldwide'

cl_dict = {}
for r in ranked.rows:
    cl_dict[r.get('country_code_complete').lower()] = r.get('Total (%)') 

worldmap_chart.add('Total Child Labor (%)', cl_dict) 
worldmap_chart.render() 

The pygal library’s World class in the maps.world module returns our map object.

cl_dict holds a dictionary where the keys are the country codes and the values are the child labor percentages.

Following the pygal documentation, this code passes the label for the data and a data dictionary.

We call the map’s render method to display the map.

We can see that render outputs the .svg to the terminal as a long, complicated string. If we want to save it in a file, we need to call a different method. pygal gives us a few options for different file types:

worldmap_chart.render_to_file('world_map.svg')

worldmap_chart.render_to_png('world_map.png')

Now when we open up our .svg or .png, we’ll see the chart shown in Figure 10-5.

Figure 10-5. World map

We strongly encourage you to check out the many other .svg options pygal provides. The documentation is full of examples, both advanced and simple, and it’s a very accessible .svg library for beginners.

Interactives

Interactives tell a story through website interactions or simulations. Because users can click around and explore via the browser, they can take in the topic at their own pace and seek out their own conclusions from the data. This can be particularly powerful for topics which require more research to fully understand.

In response to the recent measles outbreak in the United States, The Guardian created an outbreak interactive allowing users to see and replay effects of potential measles outbreaks with different vaccination rates. This interactive displays different scenarios The Guardian staff researched and coded. Not every simulation turns out with the same outcome, allowing users to understand there is an element of chance, while still showing probability (i.e., less chance of infection with higher vaccination rates). This takes a highly politicized topic and brings out real-world scenarios using statistical models of outbreaks.

Although interactives take more experience to build and often require a deeper coding skillset, they are a great tool, especially if you have frontend coding experience.

As an example, for our child labor data we could build an interactive showing how many people in your local high school would have never graduated due to child labor rates if they lived in Chad. Another interactive could show goods and services available in your local mall that are produced using child labor. These take hard-to-visualize information and present it to your audience so they can understand the data and connect with the story.

Words

Telling the story with words comes naturally for writers and reporters. Regardless of what visual methods you use, any writing or words you include should be useful and appropriate for your intended audience. You might want to interview or speak with topic experts. Including their words, ideas, and conclusions on the findings will help your audience synthesize the information.

If you are researching how a local school board is determining budgeting for upcoming school years, you could speak to board members and perhaps get inside information regarding proposed changes. If you are researching upcoming product releases for your company, you might want to talk to some of the key decision makers to determine what may be on the horizon.

For more information on interviewing and choosing quotes to accompany your story, Poynter has some great tips on how to become a better interviewer, and Columbia University’s Interview Principles shares insights on how to prepare for your interview and determine how to use different interviews for your projects’ needs.

Images, Video, and Illustrations

If your story has a strong visual element, images and video can enhance the storytelling. For example, videotaping interviews with people related to your topic can show a personal side of the data and may uncover other perspectives or future avenues of investigation.

As with videos, images paint a picture for your audience. As we’ve all experienced with graphic images of war or other gruesome current events, they can impact our interpretation of a story. However, using images to simply shock your audience takes away from the careful research you put into your work. Use your discretion to find a good compromise for your storytelling.

If you don’t have access to photos and videos related to your topic or the ability to collect your own, illustrations can be used for visual storytelling. A Washington Post interactive on healthy vs. unhealthy office spaces uses an illustration to show the story concepts.

For our child labor data, it’s unlikely we’ll have a chance to collect videos and photos ourselves of the greatest violations uncovered in our data analysis. However, we can use photos from past child labor exposés (with permission and attribution) as a representation of children still affected by the issue worldwide.

Using Available Sites

Many of the websites designed for publishing data cater to writers and investigators like you, who want to share reporting or ideas and easily distribute them on the Web. Here are some of the best options.

Open Source Platforms: Starting a New Site

We’ve mentioned options for getting a new site up and running using free or low-cost platforms like Squarespace and WordPress; but if you’d like to launch, run, and maintain your own site, you can pick from a wealth of great open source platforms.

Jupyter (Formerly Known as IPython Notebooks)

We’ve covered how to share your findings, but what if you’d also like to share your code, data, and process? Depending on your audience, it may be appropriate to share your code and allow people to interact directly with it. If you are sharing with colleagues or peers, this is a great way to show how you went about your research.

Jupyter notebooks (formerly known as IPython notebooks) are a great way to share your Python code and charts generated by your code. These notebooks combine the ease of using a browser with IPython’s interactive features. Notebooks are also tremendously useful for iterative code design and data exploration.

Getting Jupyter up and running locally is simple; just run this command:

pip install "ipython[notebook]"

To start your notebook server, run:

ipython notebook

You should see some terminal output like:

[NotebookApp] Using MathJax from CDN: https://cdn.mathjax.org/mathjax/latest/
    MathJax.js
[NotebookApp] Terminals not available (error was No module named terminado)
[NotebookApp] Serving notebooks from local directory: /home/foo/my-python
[NotebookApp] 0 active kernels
[NotebookApp] The IPython Notebook is running at: http://localhost:8888/
[NotebookApp] Use Control-C to stop this server and shut down all kernels.
Created new window in existing browser session.

This is the notebook server starting up. You will also see a new browser window (or tab) open to an empty notebook.

Depending on what folder you are running your notebook in, you might see some files in your browser. The notebook server runs directly from whatever folder you are in and displays that folder’s contents. We recommend creating a new folder for your notebooks. To stop the server so you can create a new folder, press Ctrl-C (Windows and Linux) or Cmd-C on a Mac in the running terminal. Make a new directory, change into it, and restart your server, like so:

mkdir notebooks
cd notebooks/
ipython notebook

Let’s begin using Jupyter by starting a new notebook. To do that, click the New drop-down menu and choose “Python 2” under the Notebooks heading. Once you have created a new notebook, give it a useful name. To do so, click on the title section (it should currently say “Untitled”) and enter a new name. Naming your notebooks will save you hours of searching later.

In Jupyter, each text area is called a cell. Notebooks support many different cell types. It’s a great idea to have some Markdown cells at the top or between sections of code to explain and document your code. Figure 10-6 shows an example of adding a header.

Figure 10-6. Adding a Markdown title

To start writing Python, simply click on the next available cell and start typing. When you are done with whatever statement or function you are writing, hit Shift+Enter. Your code will execute and a new cell will appear for your next Python code. As you can see in Figure 10-7 and your own notebook, you can see any and all outputs you’d expect in a normal Python interpreter.

Figure 10-7. Working in Jupyter

There are a ton of great Jupyter (and IPython) notebook tutorials available, but a good starting point might be to retry some code we’ve been using in this book.

When you are done using a notebook, hit the Save button (to make sure it creates a new checkpoint so your files are updated). If you are done with a particular notebook but still using other notebooks, it’s a good idea to stop the old notebook process. To do so, navigate to the Running tab in your server and click the Shutdown button. When you are done with all of your notebooks, save them all and shut down your server in the running notebook terminal using Ctrl-C or Cmd-C.