# Author Archives: hussainather

## How to Determine the Modulus of Rupture

## Difference Between a Diode & Zener Diode

## How to Check a Transistor With a Digital MultiMeter

## How to Convert Miles Walked to MPH

## How to Find the Final Velocity of any Object

## The Journalist’s Guide to Statistics

There are three kinds of lies: lies, damned lies, and statistics.

Mark Twain, “My Autobiography”

Journalists need a good understanding of numbers. Tapping into the power of data would let them create more meaningful and effective stories. But making sense of numbers can be difficult. Reporting on data is often not as straightforward or manageable as other types of journalism. Writers need to separate signal from noise.

What’s more, researchers and writers need to know the context of data to draw appropriate conclusions. You can know everything about how candidates in an election fare against one another through polls and surveys, but, until you know the causes behind why people would vote that way, you can’t say much about those statistics. I’ve written more here on the nature of causation in the context of scientific research. This guide provides a logical, reader-friendly approach to writers wanting to harness the power of statistics.

## Table of contents:

## 1. Know the numbers

Too often, writers throw around numbers not knowing what they mean. Here is a run-down of statistics terms you should know as a journalist:

**Bayesian statistics**

- If it rains, how does that affect which football team will win? This branch of statistics lets you figure out how likely something may occur based on how it depends on other factors. This lets you account for factors like false positives (when an experiment detects something that doesn’t exist) such as medical screening flagging false cues as cancer. With Bayesian models, you can account for different sources of information in putting together these conditional probabilities.
- Using Bayesian statistics to predict how likely future events are is “Bayesian inference.”

**Beta distribution**

- Using a pre-defined distribution, you can determine how well a baseball player will do at the beginning of a season even when you haven’t collected much data so far. Using her batting average of .270, you can create beta distribution (shown above with α = .81 and β = .219. The average is .270 and the standard deviation is σ
^{2}= .115. - If you don’t know the exact probability something occurs, you can figure out how which probability is most likely by selecting it from a beta distribution of probabilities. You can use α and β to calculate the mean μ and standard deviation σ with:

- You’ll also find
**binomial distributions**which use the same probability for all trials instead of letting it change.

**Chi-square test (χ**

^{2}test)- Suppose you wanted to find the relationship between being HIV positive and sexual preference. You survey 30 males and find the following data (in a contingency table):
- If you have an expectation or prediction of what your results should look like, the chi-square test compares them to what you actually observe to tell you how well your predictions match what happens. This example is borrowed from David Stockburger at Missouri State.
- Researchers calculate this by finding the difference between observed and expected values using the formula χ
^{2}= (observed − expected)^{2}/expected. - Sometimes you’ll see the difference between observed and expected values referred to as the “residual.”

Sexual preference | ||||
---|---|---|---|---|

Male | Female | Both | Total | |

HIV+ | 4 | 2 | 3 | 9 |

Not HIV+ | 3 | 16 | 2 | 21 |

7 | 18 | 5 |

Sexual preference | ||||
---|---|---|---|---|

Males | Females | Both | Total | |

HIV+ | ||||

Observed (O) | 4 | 2 | 3 | 9 |

Expected (E) | (9*7)/30 = 2.1 | (9*18)/30 = 5.4 | (9*5)/30=1.5 | |

(O-E) | 1.9 | -3.4 | -1.5 | |

(O-E)^2 | 3.61 | 11.56 | 2.25 | |

Not HIV+ | ||||

Observed (O) | 3 | 16 | 2 | 21 |

Expected (E) | (21*7)/30 = 4.9 | (21*18)/30 = 12.6 | (21*5)/30 = 3.5 | |

(O-E) | -1.9 | 3.4 | -1.5 | |

(O-E)^2 | 3.61 | 11.56 | 2.25 | |

30 |

**Confounding variable**

- If you want to test if texting leads to an increase in crashes, you would want to make sure that text messages, not weather or traffic, cause the crashes. These extra variables the study doesn’t account for are confounding variables.

**Controlled experiment**

- If you give a drug to students to observe how it affects sleep, you should compare this group (the treatment group) to a controlled group, a set of students under the same conditions, but without the drug. This makes sure you can determine that it was the drug causing differences in sleep and not some other variable.

**Correlation**

- This tells you how well two variables are related to one another. Two stocks that change in similar ways to one another over time may be correlated.

**Fisher’s exact test**

Cured | Not Cured | Total | |
---|---|---|---|

Drug A | 42 | 58 | 100 |

Drug B | 14 | 86 | 100 |

Total | 56 | 144 |

- Similar to the chi-square test, this test compares whether an outcome occurs using a contingency table (shown above). There’s no formal calculation, but it can give you an idea of the probability an effect occurs.

**Histogram**

- This tells you how data is distributed with the normal distribution shown above. The height of each bar shows you how many data points in the bin along the x-axis or how likely it is to fall in that bin. For probabilities, the area of the bins should equal 100 percent.

**Margin of error**

- When you make a measurement, the margin of error (sometimes called “uncertainty”) tells you how much that measurement can change due to other factors. You’ll typically find this in a range of a confidence interval, such as “40 percent +/- 1 percent.”
- If you’re polling a sample of people, the margin of error can tell you how close the sample is as representative of the entire population.

- Writer Robert Niles defines this as “1 divided by the square root of the number of people in the sample.”
- You can further break down error into
**bias**and**systematic****error**:- The same way standing on a weighing scale while wearing clothes makes you heavier, a bias creates an error based on how you measure something.
- If, instead, the weighing scale itself isn’t calibrated properly, there’s a systematic error. This affects all results due to the nature of your measuring equipment itself.

**Mean**

- This is the average of a set of data points, generally written using μ. When dealing with statistics, keep your language precise to communicate the most effective message possible. If the average life expectancy in the U.S. is 79 years, know the standard deviation and sample size. You may not need to report those factors, but they’ll help you put your averages in context.
- When journalists write about the “average citizen” or the “average voter,” in most cases, they’re not referring to the strict mathematical definition of an average (the sum of each data point divided by the number of data points). Rather, journalists tend to refer to the “average” as a common, representative individual in a population. Keep in mind the statistical average only represents this “average individual” based on how the standard deviation and sample size.

**Median**

- If you listed your data points from highest to lowest, the value in the middle is the median. Because this doesn’t depend on how far spread out or varied the data points are, the median is, more or less, the “middle.” It doesn’t matter that the richest person in America makes four times as much as the middle-class. What matters is whether it’s greater or lesser than those in the middle.

- In some cases, the median can give you a more accurate idea of the “average” person in a population when reporting. Make sure you understand where the median falls in the space between the highest and lowest data point. That can tell you more about how the numbers are distributed.
- Paleontologist Stephen Jay Gould quoted Twain’s “damned lies” quote to argue that using the eight-month median survival time for peritoneal mesothelioma was misleading. Many people, like Gould who lived for two more decades, would live for years and take an optimistic, positive view of statistics in general.

**Mode**

- The mode is the number occurring most often. This simple and clean measurement can tell you who’s the most popular candidate in an election. You won’t see this much, but it’s helpful for comparing raw numbers against one another like sales figures.

**Multiplication rule**

- If there’s a 1/2 chance you’ll draw a red card from a deck and a 1/13 chance the card is a King, then there chance to draw aa red King is 1/2*1/13= 1/26. This holds for independent events.
- Keep track of how one event may affect the other. If you draw red card from a deck (with a 1/2 probability), the chance the next card is red is now 25/51 because you have one less red card in the deck.

**Normal (or standard or Gaussian) distribution**

- Imagine taking a set of heights in a population and graphing the heights on the x-axis with how many times they occur on the y-axis. If the data is “normally” distributed, then most people should fall around an average height with fewer and fewer heights farther away from this average as shown in the graph above. In the normal distribution, you can define this distribution using the mean and standard deviation with σ as the standard deviation and μ as the mean.

- The normal distribution centers on the average and, with a greater standard deviation, it becomes more spread out in both directions. You most likely won’t report the normal distribution explicitly in a news story.
- The standard deviation lets you compare the mean to the distribution. About 70 percent of people are one standard deviation from the mean (in either direction), 95 percent are two standard deviations away and almost everyone, three standard deviations away. The Z-score also tells you how far away a data point is from the mean.
- If you wanted to test if a new psychiatric drug changed the frequency of mood swings, you might measure the number of mood swings in a population with the drug and a population without. If you found that the means of the two distributions are separated by a certain number of standard deviations, you can convert that to a p-value. The smaller the p-value, the more likely it is that the drug itself, not some random variable. This gives you a probability that the drug works.

**Null hypothesis (H**

_{0})- To figure out if smoking truly causes cancer, scientists look for ways to show that “smoking doesn’t cause cancer” is false. This is a null hypothesis (H
_{0}), usually used to show that there is no effect or no relationship between what you want to show. In the words of scientists, they look for ways to “reject the null hypothesis.” - When creating a standard distribution, the p-value tells you how likely it is to reject the null hypothesis.

**Quartile**

- Split the data into four equally sized groups. The lowest quarter is the lower quartile, the highest quarter is the upper quartile and everything in between is the middle quartile. The range of the middle quartile is the interquartile range.

**Range**

- This is the highest value minus the smallest. Note that the range is a single number, not a range of numbers.

**Regression**

- Regression tests what causes something to happen. If smoking really does cause an increase in cancer, then you should see it if you make a graph of cancer prevalence vs. smoking like the graph above, usually with a line of best fit (shown in red). Given enough linear regressions, you can separate a scientific observation explain the relationship between into the variables that cause it.
- Keep in mind correlation does not imply causation. If you find that video game sales rise around similar times when violent crimes occur, you still need to show that one caused the other before drawing conclusions between the two. Otherwise things may be a coincidence or just a matter of randomness.
- You’ll see an R value (how well one variable explains the other) or an R
^{2}value (how well the model fits the data). The ANOVA (Analysis of Variance) creates an R^{2}and whether the result is “statistically significant.”

**Standard deviation**

- The standard deviation is how widely values are spread apart or how much the data varies. This, along with mean, defines a normal distribution.
- You can calculate the standard deviation of the population the formula above with x̄ as the average of data points x over n number of data points with Σ the sum of each value (x
_{i}– x̄)^{2}. If you want the standard deviation of a specific sample, use n-1 instead of n in the denominator because you only know the mean of that sample, not the population. - The standard deviation squared gives you the variance. Sometimes researchers use “deviation” and “variance” interchangeably so keep in mind the difference.

**Stochastic models**

- These are ways to predict future data like financial portfolios or weather forecasts that depend on randomness. Using distributions like the normal or beta distributions, you can simulate what future data will look like and form predictions.

**Variable**

- Variables are anything that differs from person to person or sample to sample.

- Categorical variables are ways of labeling people into groups (like biological sex or state of residence), continuous ones lie on a scale (like age or temperature), qualitative ones use adjectives (like colors) and random variables are what scientists measure as outcomes of experiments (like flipping a coin).

## 2. Study the source

The Society for Professional Journalists dictates you should remain accountable and transparent, seek the truth and report it and act independently. In the context of numbers, this means remaining open and honest in data analysis, scrutinizing findings and mathematical methods and doing so free from anything that my interfere with an investigation. After you know the definitions of statistics, you need to know where those numbers came from. This means not only knowing how data was collected, but appealing to statistics in a way that reflects the current principles of journalism.

Writer William Davies argued the authority of statistics and the researchers who study them is declining. In a post-statistical society, journalists need to remain objective and skeptical to statistics while still appreciating them for what they are. It won’t be a battle between elite facts and populist feelings, but, rather, public rhetoric and the forces against it.

Remember to keep numbers in context of their original source or how they were measured. If someone asks where you got your information from or how a number was calculated, you should have an appropriate answer. If you’re reporting a p-value for biomedical study, which variables were measured? How does the standard deviation affect the certainty of the results? Make sure that, for whatever claim or argument a scientist has put forward in a study, you can be responsible for however you report on it.

As you become more statistically literate, you’ll naturally reevaluate how you reason. Becoming aware of common fallacies and pitfalls journalists fall into can make you more prepared to present accurate scientific findings. Be careful when you read a study suggesting that, because people are losing jobs, the economy must be doing poorly or that, if a study found no evidence on the link between fossil fuels and climate change that you conclude there’s evidence of absence. You can begin to see through the arguments that the majority of people saying something is true makes it true and, instead, take a more empirical approach to forming an opinion.

Much more sinister are those who prey on individuals without a strong statistical or mathematical literacy. Showing that the cost of attending college is a smaller percent of the national debt now than it was in the 1960s doesn’t show that today’s college students pay less for their education. As you study the context and nuances of scientific findings, you’ll become better prepared to separate signal from noise in these situations.

If there’s a 20 percent chance of rain, does that mean it will rain 20 percent of the time? If a medical procedure has a false positive rate of 1 out of 10 trials, how does that change its effectiveness? It’s easy to appeal to the authority of statistics and science without investigating for yourself. Check what experiments were performed or the historical use of tests like the Fisher’s exact test.

This way, you’re acting as both a writer and a researcher. The key here is to avoid resorting to phrases like “studies show” or “survey says,” and, instead, ask yourself if you really know what the scientific studies purport. Many times scientists will refer to terms like “standard deviation” or “variance” interchangeably so make sure you know what’s being reported.

## 3. Remember the reader

Now that you have a deep understanding of what you’re reporting and what it means, you need to put it in a context that a general audience can understand.

If you ask a drunkard what number is larger, 2/3 or 3/5, he won’t be able to tell you. But if you rephrase the question: what is better, 2 bottles of vodka for 3 people or 3 bottles of vodka for 5 people, he will tell you right away: 2 bottles for 3 people, of course.

Edward Frenkel, “Love and Math: The Heart of Hidden Reality”

In the quote above, how does drunkard arrive at the correct answer? The statistics are presented differently. In the rephrased question, he has a more “tangible,” usable way of understanding how the proportions of vodka would be arise from the distribution among people.

How well do you understand what you write? Try answering this question to find out.

Imagine you conduct a breast cancer screening using mammography in a certain region. You know the following information about the women in this region: The probability that a woman has breast cancer is 1 percent (known as “prevalence”). If a woman has breast cancer, the probability that she tests positive is 90 percent (“sensitivity”). If a woman does not have breast cancer, the probability that she nevertheless tests positive is 9 percent (false-positive rate). A woman tests positive. She wants to know from you whether that means that she has breast cancer for sure, or what the chances are. What is the best answer?

**A.**The probability that she has breast cancer is about 81 percent.

**B.**Out of 10 women with a positive mammogram, about 9 have breast cancer.

**C.**Out of 10 women with a positive mammogram, about 1 has breast cancer.

**D.**The probability that she has breast cancer is about 1 percent.

When German psychologist Gerd Gigerezner posed the question to about 1000 gynecologists, about 21 percent chose the correct answer, **C**. While that is a little worse than random guessing, I must admit that, on my first attempt, I failed to answer this question correctly, as well. Through his research, Gigerezner has crafted a theory of understanding statistics that would help us in situations like this.

Similar to Frenkel’s example of the fractions of vodka, psychologists like Daniel Kahneman and Gerd Gigerezner have shown that asking statistics questions in different ways can influence the ways we understand them. For example, when the information preceding the question is framed differently (as shown below), 87 percent of gynecologists answered correctly.

Assume you conduct breast cancer screening using mammography in a certain region. You know the following information about the women in this region:

- Ten out of every 1,000 women have breast cancer
- Of these 10 women with breast cancer, 9 test positive
- Of the 990 women without cancer, about 89 nevertheless test positive

In both examples (of breast cancer screening and of bottles of vodka), when we change from “conditional probabilities” to “natural frequencies,” we suddenly understand statistics much better. Like Gigerezner, I believe we can teach the appropriate way to interpret statistics, and, with the effect it has on our health and society, we have a moral imperative to do so.

This isn’t a simple case of deliberately communicating false information or lying about the statistics we use. While there may be agendas and conflicts-of-interests between professionals (including scientists), we simply don’t understand how to interpret statistics. And, in the field of medicine, this can have disastrous results. We make poor decisions about how long a patient may live, how prevalence of cancer among smokers, and understanding the harms and benefits of screening for breast cancer.

## 4. Present the product

Many ways of visualizing, illustrating or explaining statistics exist no matter the medium. Looking across *FiveThirtyEight*, *The Guardian*‘s Data section or other data journalism publications, you can find effective ways of communicating complicated concepts either to the audience of your publication or to colleagues. Use figures and graphs to explain take-home messages and conclusions from your reporting. Make sure they’re easy to read and follow.

Python and R offer ways of visualizing statistical findings with R providing much more extensive libraries for statistics than Python. My work in creating interactive network graphs, word clouds and even periodic tables show some examples. To produce a confusion matrix like the one shown below, you can use this code.

It’s a good idea to value openness and transparency with your code and work in creating visualizations. This gives other researchers and writers ways to check and re-examine what you’ve done. The chart below shows how much the University of California Santa Cruz Science Communication class of 2020 used Slack during their fall quarter (with its code here). Interactive graphs give the reader a better sense of data and let you communicate more information as effective as possible.

Make sure to perform statistical tests to confirm results from research when you report. In the movie “Rosencrantz and Guildenstern Are Dead,” the two protagonists flip a coin heads 92 times in a row. The chances this may happen is about 1 in 5 octillion. In a more realistic setting, the Dallas Cowboys have won 6 out of 8 coin tosses in the history of Super Bowls. In R, you can use a binomial distribution to return the value 0.109375.

```
probability <- .5 # Set the odds of getting heads to .5.
wins <- 6 # number of winning coin flips
totalFlips <- 8 # total coin flips
dbinom(wins, totalFlips, probability)
> 0.109375
```

In the code, the comments are written with a `#`

in front of them explaining what each line does. These comments are notes programmers write to explain things without affecting the code.

With enough coin tosses you can make a graph of how these probabilities are based on the number of heads and flips. When you only have two outcomes (heads or tails), it’s a Bernoulli distribution.

Not all visuals are created equal. Statisticians William Cleveland and Robert McGill found that people can tell differences between length and angles much more easily than shapes and colors. This means, where appropriate, you should use charts and plots that rely on lines slopes when possible and avoid pie charts.

No matter the code or plot you make, taking an independent investigative approach to statistics can let you harness the power of data in your stories. Becoming more savvy with numbers and calculations can let you present more accurate, verified findings. Though you can’t just drop statistics without context or understanding of how they came about, newsrooms and other workplaces for publications can use a more empirical approach in their findings in presenting scientific research for what it is. Whether its journalists themselves or a hired analyst creating statistical models of disease prevalence, they should adhere to the established standards of journalism.

Journalism emphasizes quick, easy-to-understand conclusions and messages. While some projects can require more complicated work flows such as Bayesian models, bootstrapping or exploratory data analysis, sometimes all that matters is whether an experiment worked or didn’t. In many cases, you simply don’t have the time or capacity to explain what a p-value or regression test is. Still, becoming statistically literate and understanding the mathematics behind calculations involved in research can make you all the more prepared in presenting stories. Being able to tell the difference between causation and correlation can save you from drawing false conclusions and make your arguments more justified on the basis of statistics. It can give you the power to check the work of others and move journalism into a domains of peer-reviewed, egalitarian work. In writing this guide, I hope to do so as well.

## The Emergent Beauty of Mathematics

Like a flower in full bloom, nature reveals its patterns shaped by mathematics. Or as particles collide with one another, they create snowflake-like fractals through emergence. How do fish swarm in schools or consciousness come about from the brain? Simulations can provide answers.

Through code, you can simulate how living cells or physical particles would interact with one another. Using equations that govern the behavior of how cells act when they meet one another or how they would grow and evolve into larger structures. In the gif above, you can use diffusion-limited aggregation to create Brownian trees. These are the structures that emerge when particles move randomly with respect to one another. Particles in fluid (like dropping color dye into water) take these patterns when you look at them under a microscope. As the particles collide and form trees, they create shapes and patterns like water crystals on glass. These visuals can give you a way of appreciating how beautiful mathematics is. The way mathematical theory can borrow from nature and how biological communities of living organisms themselves depend on physical laws shows how such an interdisciplinary approach provides a way to bridge different disciplines.

In the code, the particles are set to move with random velocities in two dimensions and, if they collide with the tree (a central particle at the beginning), they form parts of the tree. As the tree grows bigger over time, it takes the shapes of branches the same way neurons in the brain form trees that send signals between one another. These fractals, in their uniqueness, give them a kind of mathematical beauty.

Flashing lights coming and going away like stars shining in the sky are more than just randomness. These models of cellular interactions are known as cellular automaton. The gif above shows an example of Conway’s game of life, a simulation of how living cells interact with one another.

These cells “live” and “die” according to four simple rules: (1) live cells with fewer than two live neighbors die, as if by underpopulation, (2) live cells with two or three live neighbors live on to the next generation, (3) live cells with more than three live neighbors die, as if by overpopulation and (4) dead cells with exactly three live neighbors become live cells, as if by reproduction.

Through these rules, specific shapes emerge such as “gliders” or “knightships” you can further describe with rules and equations. You’ll find natural versions of cells obeying rules like the colorful patterns on a seashell. Complex structures emerging from more basic, fundamental sets of rules unite these observations. While the beauty of these structures becomes more and more apparent from the patterns between different disciplines, searching for these patterns in other contexts can be more difficult such as human behavior.

Recent writing like *Genesis: The Deep Origin of Societies* by biologist E.O. Wilson take on the debate over how altruism in humans evolved. While the shape of snowflakes can emerge from the interactions between water molecules, humans getting along with one another seems far more complicated and higher-level. Though you can find similar cooperation in ants and termites creating societies, how did science let this happen?

Biologists have answered that organisms choose to mate with individuals and increase the survival chances of themselves and their offspring while passing on their genes. Though they’ve argued this for decades, Wilson offers a contrary point of view. In groups, selfish organisms defeat altruistic ones, but altruistic groups beat selfish groups overall. This group selection drives the emergence of altruism. Through these arguments, both sides have appealed to the mathematics of nature, showing its growing importance in recognizing the patterns of life.

Wilson clarifies that data analysis and mathematical modeling should come second to the biology itself. Becoming experts on organisms themselves should be a priority. Regardless of what form it takes, the beauty is still there, even if it’s below the surface.

## How to Create Interactive Network Graphs (from Twitter or elsewhere) with Python

In this post, a gentle introduction to different Python packages will let you create network graphs users can interact with. Taking a few steps into graph theory, you can apply these methods to anything from links between the severity of terrorist attacks or the prices of taxi cabs. In this tutorial, you can use information from Twitter to make graphs anyone can appreciate.

The code for steps 1 and 2 can be found on GitHub here, and the code for the rest, here.

## Table of contents:

- Get Started
- Extract Tweets and Followers
- Process the Data
- Create the Graph
- Evaluate the Graph
- Plot the Map

### 1. Get Started

Make sure you’re familiar with using a command line interface such as Terminal and you can download the necessary Python packages (chart-studio, matplotlib, networkx, pandas, plotly and python-twitter). You can use Anaconda to download them. This tutorial will introduce parts of the script you can run from the command line to extract tweets and visualize them.

If you don’t have a Twitter developer account, you’ll need to login here and get one. Then create an app and find your keys and secret codes for the consumer and access tokens. This lets you extract information from Twitter.

### 2. Extract Tweets and Followers

To extract Tweets, run the script below. In this example, the tweets of the UCSC Science Communication class of 2020 are analyzed (in `screennames`

) so their Twitter handles are used. Replace the variables currently defined as `None`

below with them. Keep these keys and codes safe and don’t share them with others. Set `datadir`

to the output directory to store the data.

The code begins with `import`

statements to use the required packages including `json`

and `os`

, which should come installed with Python.

```
import json
import os
import pickle
import twitter
screennames = ["science_ari", "shussainather", "laragstreiff", "scatter_cushion", "jessekathan", "jackjlee", "erinmalsbury", "joetting13", "jonathanwosen", "heysmartash"]
CONSUMER_KEY = None
CONSUMER_SECRET = None
ACCESS_TOKEN_KEY = None
ACCESS_TOKEN_SECRET = None
datadir = "data/twitter"
```

Extract the information we need. This code goes through each screen name and accesses their tweet and follower information. It then saves the data of both of them to output JSON and pickle files.

`t = twitter.Api(consumer_key = CONSUMER_KEY,`

consumer_secret = CONSUMER_SECRET,

access_token_key = ACCESS_TOKEN_KEY,

access_token_secret = ACCESS_TOKEN_SECRET)

for sn in screennames:

"""

For each user, get the followers and tweets and save them

to output pickle and JSON files.

"""

fo = datadir + "/" + sn + ".followers.pickle"

# Get the follower information.

fof = t.GetFollowers(screen_name = sn)

with open(fo, "w") as fofpickle:

pickle.dump(fof, fofpickle, protocol = 2)

with open(fo, "r") as fofpickle:

with open(fo.replace(".pickle", ".json"), "w") as fofjson:

fofdata = pickle.load(fofpickle)

json.dump(fofdata, fofjson) # Get the user's timeline with the 500 most recent tweets.

timeline = t.GetUserTimeline(screen_name=sn, count=500)

tweets = [i.AsDict() for i in timeline]

with open(datadir + "/" + sn + ".tweets.json", "w") as tweetsjson:

json.dump(tweets, tweetsjson) # Store the informtion in a JSON.

This should extract the follower and tweets and save them to pickle and JSON files in the `datadir`

.

### 3. Process the Data

Now that you have an input JSON file of tweets, you can set it to the `tweetsjson`

variable in the code below to read it as a `pandas`

DataFrame.

For the rest of the tutorial, start a new script for convenience.

`import json`

import matplotlib.pyplot as plt

import networkx as nx

import numpy as np

import pandas as pd

import re`from plotly.offline import iplot, plot`

from operator import itemgetter

Use `pandas`

to import the JSON file as a `pandas`

DataFrame.

`df = pd.read_json(tweetsjson)`

Set `tfinal`

as the final DataFrame to make.

`tfinal = pd.DataFrame(columns = ["created_at", "id", "in_reply_to_screen_name", "in_reply_to_status_id", "in_reply_to_user_id", "retweeted_id", "retweeted_screen_name", "user_mentions_screen_name", "user_mentions_id", "text", "user_id", "screen_name", "followers_count"])`

Then, extract the columns you’re interested in and add them to `tfinal`

.

`eqcol = ["created_at", "id", "text"]`

tfinal[eqcol] = df[eqcol]

tfinal = filldf(tfinal)

tfinal = tfinal.where((pd.notnull(tfinal)), None)

Use the following functions to extract information from them. Each function extracts information form the input `df`

DataFrame and adds it to the `tfinal`

one.

First, get the basic information: screen name, user ID and how many followers.

`def getbasics(tfinal):`

"""

Get the basic information about the user.

"""

tfinal["screen_name"] = df["user"].apply(lambda x: x["screen_name"])

tfinal["user_id"] = df["user"].apply(lambda x: x["id"])

tfinal["followers_count"] = df["user"].apply(lambda x: x["followers_count"])

return tfinal

Then, get information on which tweets have been retweeted.

`def getretweets(tfinal):`

"""

Get retweets.

"""

# Inside the tag "retweeted_status" will find "user" and will get "screen name" and "id".

tfinal["retweeted_screen_name"] = df["retweeted_status"].apply(lambda x: x["user"]["screen_name"] if x is not np.nan else np.nan)

tfinal["retweeted_id"] = df["retweeted_status"].apply(lambda x: x["user"]["id_str"] if x is not np.nan else np.nan)

return tfinal

Figure out which tweets are replies and to who they are replying.

`def getinreply(tfinal):`

"""

Get reply info.

"""

# Just copy the "in_reply" columns to the new DataFrame.

tfinal["in_reply_to_screen_name"] = df["in_reply_to_screen_name"]

tfinal["in_reply_to_status_id"] = df["in_reply_to_status_id"]

tfinal["in_reply_to_user_id"]= df["in_reply_to_user_id"]

return tfinal

The following function runs each of these functions to get the information into `tfinal`

.

`def filldf(tfinal):`

"""

Put it all together.

"""

getbasics(tfinal)

getretweets(tfinal)

getinreply(tfinal)

return tfinal

You’ll use this `getinteractions()`

function in the next step when creating the graph. This takes the actual information from the `tfinal`

DataFrame and puts it into the format that a graph can use.

`def getinteractions(row): """ Get the interactions between different users. """ # From every row of the original DataFrame. # First we obtain the "user_id" and "screen_name". user = row["user_id"], row["screen_name"] # Be careful if there is no user id. if user[0] is None: return (None, None), []`

For the remainder of the `for`

loop, get the information if it’s there.

```
# The interactions are going to be a set of tuples.
interactions = set()
# Add all interactions.
# First, we add the interactions corresponding to replies adding
# the id and screen_name.
interactions.add((row["in_reply_to_user_id"],
row["in_reply_to_screen_name"]))
# After that, we add the interactions with retweets.
interactions.add((row["retweeted_id"],
row["retweeted_screen_name"]))
# And later, the interactions with user mentions.
interactions.add((row["user_mentions_id"],
row["user_mentions_screen_name"]))
# Discard if user id is in interactions.
interactions.discard((row["user_id"], row["screen_name"]))
# Discard all not existing values.
interactions.discard((None, None))
# Return user and interactions.
return user, interactions
```

### 4. Create the Graph

Initialize the graph with `networkx`

.

`graph = nx.Graph()`

Loop through the `tfinal`

DataFrame and get the interaction information. Use the `getinteractions`

function to get each user and interaction involved with each tweet.

`for index, tweet in tfinal.iterrows():`

user, interactions = getinteractions(tweet)

user_id, user_name = user

tweet_id = tweet["id"]

for interaction in interactions:

int_id, int_name = interaction

graph.add_edge(user_id, int_id, tweet_id=tweet_id)

graph.node[user_id]["name"] = user_name

graph.node[int_id]["name"] = int_name

### 5. Evaluate the Graph

In the field of social network analysis (SNA), researchers use measurements of nodes and edges to tell what graphs re like. This lets you separate the signal from noise when looking at network graphs.

First, look at the degrees and edges of the graph. The `print`

statements should print out the information about these measurements.

`degrees = [val for (node, val) in graph.degree()]`

print("The maximum degree of the graph is " + str(np.max(degrees)))

print("The minimum degree of the graph is " + str(np.min(degrees)))

print("There are " + str(graph.number_of_nodes()) + " nodes and " + str(graph.number_of_edges()) + " edges present in the graph")

print("The average degree of the nodes in the graph is " + str(np.mean(degrees)))

Are all the nodes connected?

`if nx.is_connected(graph):`

print("The graph is connected")

else:

print("The graph is not connected")

print("There are " + str(nx.number_connected_components(graph)) + " connected in the graph.")

Information about the largest subgraph can tell you what sort of tweets represent the majority.

`largestsubgraph = max(nx.connected_component_subgraphs(graph), key=len)`

print("There are " + str(largestsubgraph.number_of_nodes()) + " nodes and " + str(largestsubgraph.number_of_edges()) + " edges present in the largest component of the graph.")

The clustering coefficient tells you how close together the nodes congregate using the density of the connections surrounding a node. If many nodes are connected in a small area, there will be a high clustering coefficient.

`print("The average clustering coefficient is " + str(nx.average_clustering(largestsubgraph)) + " in the largest subgraph")`

print("The transitivity of the largest subgraph is " + str(nx.transitivity(largestsubgraph)))

print("The diameter of our graph is " + str(nx.diameter(largestsubgraph)))

print("The average distance between any two nodes is " + str(nx.average_shortest_path_length(largestsubgraph)))

Centrality tells you how many direct, “one step,” connections each node has to other nodes in the network, and there are two ways to measure it. “Betweenness centrality” represents which nodes act as “bridges” between nodes in a network by finding the shortest paths and counting how many times each node falls on one. “Closeness centrality,” instead, scores each node based on the sum of the shortest paths.

`graphcentrality = nx.degree_centrality(largestsubgraph)`

maxde = max(graphcentrality.items(), key=itemgetter(1))

graphcloseness = nx.closeness_centrality(largestsubgraph)

graphbetweenness = nx.betweenness_centrality(largestsubgraph, normalized=True, endpoints=False)

maxclo = max(graphcloseness.items(), key=itemgetter(1))

maxbet = max(graphbetweenness.items(), key=itemgetter(1))

`print("The node with ID " + str(maxde[0]) + " has a degree centrality of " + str(maxde[1]) + " which is the max of the graph.")`

print("The node with ID " + str(maxclo[0]) + " has a closeness centrality of " + str(maxclo[1]) + " which is the max of the graph.")

print("The node with ID " + str(maxbet[0]) + " has a betweenness centrality of " + str(maxbet[1]) + " which is the max of the graph.")

### 6. Plot the Map

Get the edges and store them in lists `Xe`

and `Ye`

in the x- and y-directions.

`Xe=[]`

Ye=[]

for e in G.edges():

Xe.extend([pos[e[0]][0], pos[e[1]][0], None])

Ye.extend([pos[e[0]][1], pos[e[1]][1], None])

Define the Plotly “trace” for nodes and edges. Plotly uses these traces as a way of storing the graph data right before it’s plotted.

`trace_nodes = dict(type="scatter", x=Xn, y=Yn, mode="markers", marker=dict(size=28, color="rgb(0,240,0)"), text=labels, hoverinfo="text")`

`trace_edges = dict(type="scatter", mode="lines", x=Xe, y=Ye, line=dict(width=1, color="rgb(25,25,25)"), hoverinfo="none")`

Plot the graph with the Fruchterman-Reingold layout algorithm. This image shows an example of a graph plotted with this algorithm, designed to provide clear, explicit ways the nodes are connected.

`pos = nx.fruchterman_reingold_layout(G)`

Use the `axis`

and `layout`

variables to customize what appears on the graph. Using the `showline=False`

, option, you will hide the axis line, grid, tick labels and title of the graph. Then the `fig`

variable creates the actual figure.

`axis = dict(showline=False,`

zeroline=False,

showgrid=False,

showticklabels=False,

title=""

)

layout = dict(title= "My Graph",

font= dict(family="Balto"),

width=600,

height=600,

autosize=False,

showlegend=False,

xaxis=axis,

yaxis=axis,

margin=dict(

l=40,

r=40,

b=85,

t=100,

pad=0,

),

hovermode="closest",

plot_bgcolor="#EFECEA", # Set background color.

)

fig = dict(data=[trace_edges, trace_nodes], layout=layout)

Annotate with the information you want others to on each node. Use the `labels`

variable to list (with the same length as `pos`

) what should appear as an annotation.

`labels = range(len(pos))`

`def make_annotations(pos, anno_text, font_size=14, font_color="rgb(10,10,10)"):`

L=len(pos)

if len(anno_text)!=L:

raise ValueError("The lists pos and text must have the same len")

annotations = []

for k in range(L):

annotations.append(dict(text=anno_text[k],

x=pos[k][0],

y=pos[k][1]+0.075,#this additional value is chosen by trial and error

xref="x1", yref="y1",

font=dict(color= font_color, size=font_size),

showarrow=False)

)

return annotations

fig["layout"].update(annotations=make_annotations(pos, labels))

Finally, plot.

`iplot(fig)`

## Make a word cloud in a single line of Python

This is a concise way to make a word cloud using Python. It can teach you basics of coding while creating a nice graphic.

It’s actually four lines of code, but making the word cloud only takes one line, the final one.

import nltk from wordcloud import WordCloud nltk.download("stopwords") WordCloud(background_color="white", max_words=5000, contour_width=3, contour_color="steelblue").generate_from_text(" ".join([r for r in open("mobydick.txt", "r").read().split() if r not in set(nltk.corpus.stopwords.words("english"))])).to_file("wordcloud.png")

## Just tell me what to do now!

The first two lines lines specify the required packages you must download with these links: `nltk`

and `wordcloud`

. You may also try these links: `nltk`

and `wordcloud`

to download them. The third line downloads the stop words (common words like “the”, “a” and “in”) that you don’t want in your word cloud.

The fourth line is complicated. Calling the `WordCloud()`

method, you can specify the background color, contour color and other options (found here). `generate_from_text()`

takes a string of words to put in the word cloud.

The `" ".join()`

creates this string of words separated by spaces from a list of words. The `for`

loop in the square brackets`[]`

creates this list of each word from the input file (in this case, `mobydick.txt`

) with the `r`

variable letting you use each word one at a time in the list.

The input file is `open()`

, `read()`

and `split()`

into its words under the condition (using `if`

) they aren’t in `nltk.corpus.stopwords.words("english")`

. Finally, `to_file()`

saves the image as `wordcloud.png`

.

## How to use this code

In the code, change `"mobydick.txt"`

to the name of your text file (keep the quotation marks). Save the code in a file `makewordcloud.py`

in the text file’s directory, and use a command line interface (such as Terminal) to navigate to the directory.

Run your script using `python makewordcloud.py`

, and check out your `wordcloud.png`

!