Mining Twitter Data with Python

Twitter is a popular social network where users can share short SMS-like messages called tweets. Users share thoughts, links and pictures on Twitter, journalists comment on live events, companies promote products and engage with customers. The list of different ways to use Twitter could be really long, and with 500 millions of tweets per day, there’s a lot of data to analyse and to play with.

This is the first in a series of articles dedicated to mining data on Twitter using Python. In this first part, we’ll see different options to collect data from Twitter. Once we have built a data set, in the next episodes we’ll discuss some interesting data applications.

1.Collecting data
2.Text Pre-processing
- 2.1 The Anatomy of a Tweet
- 2.2 How to Tokenise a Tweet Text
3.Term Frequencies
4.Rugby and Term Co-Occurrences
5.Data Visualisation Basics
- 5.1 From Python to Javascript with Vincent
- 5.2 Time Series Visualisation
6.Sentiment Analysis Basics
7.Geolocation and Interactive Maps

1.Collecting data

1.1 Register Your App

In order to have access to Twitter data programmatically, we need to create an app that interacts with the Twitter API.

The first step is the registration of your app. In particular, you need to point your browser to http://apps.twitter.com, log-in to Twitter (if you’re not already logged in) and register a new application. You can now choose a name and a description for your app (for example “Mining Demo” or similar). You will receive a consumer key and a consumer secret: these are application settings that should always be kept private. From the configuration page of your app, you can also require an access token and an access token secret. Similarly to the consumer keys, these strings must also be kept private: they provide the application access to Twitter on behalf of your account. The default permissions are read-only, which is all we need in our case, but if you decide to change your permission to provide writing features in your app, you must negotiate a new access token.

Important Note: there are rate limits in the use of the Twitter API, as well as limitations in case you want to provide a downloadable data-set, see:

https://dev.twitter.com/overview/terms/agreement-and-policy

https://dev.twitter.com/rest/public/rate-limiting

1.2 Accessing the Data

Twitter provides REST APIs you can use to interact with their service. There is also a bunch of Python-based clients out there that we can use without re-inventing the wheel. In particular, Tweepy in one of the most interesting and straightforward to use, so let’s install it:

pip install tweepy==3.5.0

In order to authorise our app to access Twitter on our behalf, we need to use the OAuth interface:

import tweepy

from tweepy import OAuthHandler

consumer_key = 'YOUR-CONSUMER-KEY'

consumer_secret = 'YOUR-CONSUMER-SECRET'

access_token = 'YOUR-ACCESS-TOKEN'

access_secret = 'YOUR-ACCESS-SECRET'

auth = OAuthHandler(consumer_key, consumer_secret)

auth.set_access_token(access_token, access_secret)

api = tweepy.API(auth)

The api variable is now our entry point for most of the operations we can perform with Twitter.

For example, we can read our own timeline (i.e. our Twitter homepage) with:

for status in tweepy.Cursor(api.home_timeline).items(10):

    # Process a single status

    print(status.text)

Tweepy provides the convenient Cursor interface to iterate through different types of objects. In the example above we’re using 10 to limit the number of tweets we’re reading, but we can of course access more. The status variable is an instance of the Status() class, a nice wrapper to access the data. The JSON response from the Twitter API is available in the attribute _json (with a leading underscore), which is not the raw JSON string, but a dictionary.

So the code above can be re-written to process/store the JSON:

for status in tweepy.Cursor(api.home_timeline).items(10):

    # Process a single status

    process_or_store(status._json)

What if we want to have a list of all our followers? There you go:

for friend in tweepy.Cursor(api.friends).items():

    process_or_store(friend._json)

And how about a list of all our tweets? Simple:

for tweet in tweepy.Cursor(api.user_timeline).items():

    process_or_store(tweet._json)

In this way we can easily collect tweets (and more) and store them in the original JSON format, fairly easy to convert into different data models depending on our storage (many NoSQL technologies provide some bulk import feature).

The function process_or_store() is a place-holder for your custom implementation. In the simplest form, you could just print out the JSON, one tweet per line:

def process_or_store(tweet):

    print(json.dumps(tweet))

1.3 Streaming

In case we want to “keep the connection open”, and gather all the upcoming tweets about a particular event, the streaming API is what we need. We need to extend the StreamListener() to customise the way we process the incoming data. A working example that gathers all the new tweets with the #python hashtag:

from tweepy import Stream

from tweepy.streaming import StreamListener

class MyListener(StreamListener):

    def on_data(self, data):

        try:

            with open('python.json', 'a') as f:

                f.write(data)

                return True

        except BaseException as e:

            print("Error on_data: %s" % str(e))

        return True

    def on_error(self, status):

        print(status)

        return True

twitter_stream = Stream(auth, MyListener())

twitter_stream.filter(track=['#python'])

Depending on the search term, we can gather tons of tweets within a few minutes. This is especially true for live events with a world-wide coverage (World Cups, Super Bowls, Academy Awards, you name it), so keep an eye on the JSON file to understand how fast it grows and consider how many tweets you might need for your tests. The above script will save each tweet on a new line, so you can use the command wc -l python.json from a Unix shell to know how many tweets you’ve gathered.

You can see a minimal working example of the Twitter Stream API in the following Gist:

##config.py

consumer_key = 'your-consumer-key'

consumer_secret = 'your-consumer-secret'

access_token = 'your-access-token'

access_secret = 'your-access-secret'

##twitter_stream_download.py

# To run this code, first edit config.py with your configuration, then:

#

# mkdir data

# python twitter_stream_download.py -q apple -d data

#

# It will produce the list of tweets for the query "apple"

# in the file data/stream_apple.json

import tweepy

from tweepy import Stream

from tweepy import OAuthHandler

from tweepy.streaming import StreamListener

import time

import argparse

import string

import config

import json

def get_parser():

    """Get parser for command line arguments."""

    parser = argparse.ArgumentParser(description="Twitter Downloader")

    parser.add_argument("-q",

                        "--query",

                        dest="query",

                        help="Query/Filter",

                        default='-')

    parser.add_argument("-d",

                        "--data-dir",

                        dest="data_dir",

                        help="Output/Data Directory")

    return parser

class MyListener(StreamListener):

    """Custom StreamListener for streaming data."""

    def __init__(self, data_dir, query):

        query_fname = format_filename(query)

        self.outfile = "%s/stream_%s.json" % (data_dir, query_fname)

    def on_data(self, data):

        try:

            with open(self.outfile, 'a') as f:

                f.write(data)

                print(data)

                return True

        except BaseException as e:

            print("Error on_data: %s" % str(e))

            time.sleep(5)

        return True

    def on_error(self, status):

        print(status)

        return True

def format_filename(fname):

    """Convert file name into a safe string.

    Arguments:

        fname -- the file name to convert

    Return:

        String -- converted file name

    """

    return ''.join(convert_valid(one_char) for one_char in fname)

def convert_valid(one_char):

    """Convert a character into '_' if invalid.

    Arguments:

        one_char -- the char to convert

    Return:

        Character -- converted char

    """

    valid_chars = "-_.%s%s" % (string.ascii_letters, string.digits)

    if one_char in valid_chars:

        return one_char

    else:

        return '_'

@classmethod

def parse(cls, api, raw):

    status = cls.first_parse(api, raw)

    setattr(status, 'json', json.dumps(raw))

    return status

if __name__ == '__main__':

    parser = get_parser()

    args = parser.parse_args()

    auth = OAuthHandler(config.consumer_key, config.consumer_secret)

    auth.set_access_token(config.access_token, config.access_secret)

    api = tweepy.API(auth)

    twitter_stream = Stream(auth, MyListener(args.data_dir, args.query))

    twitter_stream.filter(track=[args.query])

2.Text Pre-processing

2.1 The Anatomy of a Tweet

Assuming that you have collected a number of tweets and stored them in JSON as suggested above, let’s have a look at the structure of a tweet:

import json

with open('mytweets.json', 'r') as f:

    line = f.readline() # read only the first tweet/line

    tweet = json.loads(line) # load it as Python dict

    print(json.dumps(tweet, indent=4)) # pretty-print

The key attributes are the following:

text: the text of the tweet itself
created_at: the date of creation
favorite_count, retweet_count: the number of favourites and retweets
favorited, retweeted: boolean stating whether the authenticated user (you) have favourited or retweeted this tweet
lang: acronym for the language (e.g. “en” for english)
id: the tweet identifier
place, coordinates, geo: geo-location information if available
user: the author’s full profile
entities: list of entities like URLs, @-mentions, hashtags and symbols
in_reply_to_user_id: user identifier if the tweet is a reply to a specific user
in_reply_to_status_id: status identifier id the tweet is a reply to a specific status

As you can see there’s a lot of information we can play with. All the *_id fields also have a *_id_str counterpart, where the same information is stored as a string rather than a big int (to avoid overflow problems). We can imagine how these data already allow for some interesting analysis: we can check who is most favourited/retweeted, who’s discussing with who, what are the most popular hashtags and so on. Most of the goodness we’re looking for, i.e. the content of a tweet, is anyway embedded in the text, and that’s where we’re starting our analysis.

We start our analysis by breaking the text down into words. Tokenisation is one of the most basic, yet most important, steps in text analysis. The purpose of tokenisation is to split a stream of text into smaller units called tokens, usually words or phrases. While this is a well understood problem with several out-of-the-box solutions from popular libraries, Twitter data pose some challenges because of the nature of the language.

2.2 How to Tokenise a Tweet Text

Let’s see an example, using the popular NLTK library to tokenise a fictitious tweet:

from nltk.tokenize import word_tokenize

tweet = 'RT @marcobonzanini: just an example! :D http://example.com #NLP'

print(word_tokenize(tweet))

# ['RT', '@', 'marcobonzanini', ':', 'just', 'an', 'example', '!', ':', 'D', 'http', ':', '//example.com', '#', 'NLP']

You will notice some peculiarities that are not captured by a general-purpose English tokeniser like the one from NLTK: @-mentions, emoticons, URLs and #hash-tags are not recognised as single tokens. The following code will propose a pre-processing chain that will consider these aspects of the language.

import re

emoticons_str = r"""

    (?:

        [:=;] # Eyes

        [oO\-]? # Nose (optional)

        [D\)\]\(\]/\\OpP] # Mouth

    )"""

regex_str = [

    emoticons_str,

    r'<[^>]+>', # HTML tags

    r'(?:@[\w_]+)', # @-mentions

    r"(?:\#+[\w_]+[\w\'_\-]*[\w_]+)", # hash-tags

    r'http[s]?://(?:[a-z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-f][0-9a-f]))+', # URLs

    r'(?:(?:\d+,?)+(?:\.?\d+)?)', # numbers

    r"(?:[a-z][a-z'\-_]+[a-z])", # words with - and '

    r'(?:[\w_]+)', # other words

    r'(?:\S)' # anything else

]

tokens_re = re.compile(r'('+'|'.join(regex_str)+')', re.VERBOSE | re.IGNORECASE)

emoticon_re = re.compile(r'^'+emoticons_str+'$', re.VERBOSE | re.IGNORECASE)

def tokenize(s):

    return tokens_re.findall(s)

def preprocess(s, lowercase=False):

    tokens = tokenize(s)

    if lowercase:

        tokens = [token if emoticon_re.search(token) else token.lower() for token in tokens]

    return tokens

tweet = "RT @marcobonzanini: just an example! :D http://example.com #NLP"

print(preprocess(tweet))

# ['RT', '@marcobonzanini', ':', 'just', 'an', 'example', '!', ':D', 'http://example.com', '#NLP']

As you can see, @-mentions, emoticons, URLs and #hash-tags are now preserved as individual tokens.

If we want to process all our tweets, previously saved on file:

with open('mytweets.json, 'r') as f:

    for line in f:

        tweet = json.loads(line)

        tokens = preprocess(tweet['text'])

        do_something_else(tokens)

The tokeniser is probably far from perfect, but it gives you the general idea. The tokenisation is based on regular expressions (regexp), which is a common choice for this type of problem. Some particular types of tokens (e.g. phone numbers or chemical names) will not be captured, and will be probably broken into several tokens. To overcome this problem, as well as to improve the richness of your pre-processing pipeline, you can improve the regular expressions, or even employ more sophisticated techniques like Named Entity Recognition.

The core component of the tokeniser is the regex_str variable, which is a list of possible patterns. In particular, we try to capture some emoticons, HTML tags, Twitter @usernames (@-mentions), Twitter #hashtags, URLs, numbers, words with and without dashes and apostrophes, and finally “anything else”. Please take a moment to observe the regexp for capturing numbers: why don’t we just use \d+? The problem here is that numbers can appear in several different ways, e.g. 1000 can also be written as 1,000 or 1,000.00 — and we can get into more complications in a multi-lingual environment where commas and dots are inverted: “one thousand” can be written as 1.000 or 1.000,00 in many non-anglophone countries. The task of identifying numeric tokens correctly just gives you a glimpse of how difficult tokenisation can be.

The regular expressions are compiled with the flags re.VERBOSE, to allow spaces in the regexp to be ignored (see the multi-line emoticons regexp), and re.IGNORECASE to catch both upper and lowercases. The tokenize() function simply catches all the tokens in a string and returns them as a list. This function is used within preprocess(), which is used as a pre-processing chain: in this case we simply add a lowercasing feature for all the tokens that are not emoticons (e.g.